root
384 lines
12 KiB
Plaintext
384 lines
12 KiB
Plaintext
const { MongoClient, ServerApiVersion } = require('mongodb');
|
|
require('dotenv').config();
|
|
const uri = process.env.URI
|
|
const cookieSchema = require("../schemas/cookieSchema")
|
|
const cooldownSchema = require("../schemas/cooldownSchema")
|
|
const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
|
|
const Discord = require('discord.js')
|
|
|
|
const client = new MongoClient(uri, {
|
|
useNewUrlParser: true,
|
|
useUnifiedTopology: true,
|
|
serverApi: ServerApiVersion.v1
|
|
});
|
|
function msToTime(duration) {
|
|
var milliseconds = parseInt((duration % 1000) / 100),
|
|
seconds = Math.floor((duration / 1000) % 60),
|
|
minutes = Math.floor((duration / (1000 * 60)) % 60),
|
|
hours = Math.floor((duration / (1000 * 60 * 60)) % 24);
|
|
|
|
hours = (hours < 10) ? "0" + hours : hours;
|
|
minutes = (minutes < 10) ? "0" + minutes : minutes;
|
|
seconds = (seconds < 10) ? "0" + seconds : seconds;
|
|
|
|
return hours + ":" + minutes + ":" + seconds;
|
|
}
|
|
async function collect(interaction, user) {
|
|
client.connect(async (err, db) => {
|
|
var dbo = db.db('test')
|
|
let id = `${interaction.guildId}-${interaction.user.id}-${interaction.commandName}-${interaction.options._subcommand}`
|
|
dbo.collection('cooldowns').findOne({
|
|
_id: id
|
|
}, async function (err, results) {
|
|
let now = Date.now()
|
|
let time = now + 3600000 // plus one hour in ms
|
|
if (results) {
|
|
if (results.cooldown > now) {
|
|
time = new Date(results.cooldown).toUTCString()
|
|
return interaction.reply({
|
|
content: `The batch is still cooking, come back in **${msToTime(results.cooldown - now)}**`,
|
|
ephemeral: true
|
|
})
|
|
}
|
|
}
|
|
addCooldown(interaction.user.id, interaction.guildId, interaction.commandName, interaction.options._subcommand, time)
|
|
|
|
|
|
var ftext = [
|
|
"I ate the rest, sorry >.<",
|
|
"Blame Abra",
|
|
"Would you like some Milk with that?",
|
|
"Careful! They're still warm :3",
|
|
"Best Batch yet!",
|
|
"These, I bequeath unto thine own self upon this day. Thou must guard them safely.",
|
|
""
|
|
]
|
|
var i = Math.floor(Math.random() * ftext.length)
|
|
//funny text at the end
|
|
|
|
var amount = Math.floor(Math.random() * 30)
|
|
//random amount between 1 and 29
|
|
if (user.id == "378135175059603457") {
|
|
//Abra Bonus
|
|
amount *= 1.25
|
|
}
|
|
|
|
await cookieSchema.findOneAndUpdate({
|
|
_id: user.id
|
|
}, {
|
|
_id: user.id,
|
|
user: user.username,
|
|
$inc: { cookies: +amount }
|
|
}, {
|
|
upsert: true
|
|
})
|
|
|
|
var response = `<@${user.id}>, 🍪 you collected ${amou*nt} cookies!! 🍪 ${ftext[i]}`
|
|
|
|
interaction.reply({
|
|
content: response
|
|
})
|
|
})
|
|
})
|
|
}
|
|
function steal(interaction, user) {
|
|
client.connect(async (err, db) => {
|
|
if (err) throw err;
|
|
let target = interaction.options.getUser('target')
|
|
let dbo = db.db("test")
|
|
|
|
if (target.id == user.id) {
|
|
return interaction.reply({
|
|
content: `C'mon, don't embarass yourself! We all know you couldn't do that, even if you tried.`,
|
|
ephemeral: true,
|
|
})
|
|
}
|
|
|
|
// get your amount of cookies
|
|
let your = await dbo.collection('cookies').findOne({
|
|
_id: user.id
|
|
})
|
|
// get their amount of cookies
|
|
let their = await dbo.collection('cookies').findOne({
|
|
_id: target.id
|
|
})
|
|
try {
|
|
if (!your.cookies) {
|
|
return interaction.reply({
|
|
content: `You need at least 1 Cookie to attempt a Robbery`,
|
|
ephemeral: true,
|
|
})
|
|
}
|
|
if (!their.cookies) {
|
|
return interaction.reply({
|
|
content: `Shame on you! They don't even have any Cookies D:`,
|
|
ephemeral: true,
|
|
})
|
|
}
|
|
} catch (error) {
|
|
return interaction.reply({
|
|
content: `How awkward...I don't know some of you!`,
|
|
ephemeral: true,
|
|
})
|
|
}
|
|
let difficulty = []
|
|
for (var i = 0; i < their.cookies; i++) {
|
|
if (i < your.cookies) {
|
|
difficulty.push(false)
|
|
} else {
|
|
difficulty.push(true)
|
|
}
|
|
}
|
|
let result = Math.floor(Math.random() * their.cookies) + 1
|
|
let response
|
|
if (!difficulty[result]) {
|
|
// author lost
|
|
response = `You were unsuccessful at robbing **${target.username}** and lost **${result}** Cookie(s)! `
|
|
if (your.cookies - result <= 0) {
|
|
result = your.cookies
|
|
response += `That's all your Cookies gone.`
|
|
}
|
|
result *= -1
|
|
|
|
} else {
|
|
//author won
|
|
response = `You've successfully stolen **${result}** Cookie(s) from **${target.username}**! `
|
|
if (their.cookies - result <= 0) {
|
|
result = their.cookies
|
|
response += `They're completely dry now.`
|
|
}
|
|
}
|
|
interaction.reply({
|
|
content: response
|
|
})
|
|
|
|
//update author's cookies
|
|
await cookieSchema.findOneAndUpdate({
|
|
_id: user.id
|
|
}, {
|
|
_id: user.id,
|
|
user: user.username,
|
|
$inc: { cookies: +result } //will decrease if it's +negativeInteger
|
|
}, {
|
|
upsert: true
|
|
})
|
|
|
|
await cookieSchema.findOneAndUpdate({
|
|
_id: target.id
|
|
}, {
|
|
_id: target.id,
|
|
user: target.username,
|
|
$inc: { cookies: -result } //will decrease if it's +negativeInteger
|
|
}, {
|
|
upsert: true
|
|
})
|
|
})
|
|
|
|
|
|
|
|
}
|
|
function check(interaction, user) {
|
|
|
|
client.connect(async function (err, db) {
|
|
let target = interaction.options.getUser('target')
|
|
|
|
if (!target) {
|
|
target = user
|
|
}
|
|
let response = `**${target.username}** has `
|
|
let dbo = db.db("test")
|
|
dbo.collection("cookies").findOne({
|
|
_id: target.id
|
|
}, function (err, results) {
|
|
let cookies
|
|
if (!results) {
|
|
cookies = 0
|
|
response += `**${cookies}** Cookies! 😔`
|
|
} else {
|
|
cookies = results.cookies
|
|
response += `**${cookies}** Cookies! 😲`
|
|
}
|
|
interaction.reply({
|
|
content: response
|
|
})
|
|
})
|
|
})
|
|
}
|
|
async function give(interaction, user) {
|
|
client.connect(async function (err, db) {
|
|
let target = interaction.options.getUser('target')
|
|
let amount = interaction.options.getInteger('amount')
|
|
let dbo = db.db('test')
|
|
|
|
//check if you have enough cookies
|
|
let your = await dbo.collection('cookies').findOne({
|
|
_id: user.id
|
|
})
|
|
|
|
if (target.id == user.id) {
|
|
return interaction.reply({
|
|
content: 'You cannot give yourself Cookies ._."'
|
|
})
|
|
}
|
|
if (your.cookies < amount) {
|
|
return interaction.reply({
|
|
content: `We don't run a charity here, get more Cookies!`
|
|
})
|
|
}
|
|
if (amount < 1) {
|
|
return interaction.reply({
|
|
content: `**${user}** shared *checks notes* **${amount}** Cookie(s) with ${target}....wait a minute!!`,
|
|
})
|
|
}
|
|
|
|
//update user's cookies
|
|
await cookieSchema.findOneAndUpdate({
|
|
_id: user.id
|
|
}, {
|
|
_id: user.id,
|
|
user: user.username,
|
|
$inc: { cookies: -amount }
|
|
}, {
|
|
upsert: true
|
|
})
|
|
|
|
//update target's cookies
|
|
await cookieSchema.findOneAndUpdate({
|
|
_id: target.id
|
|
}, {
|
|
_id: target.id,
|
|
user: target.username,
|
|
$inc: { cookies: +amount }
|
|
}, {
|
|
upsert: true
|
|
})
|
|
await delay(200)
|
|
interaction.reply({
|
|
content: `**${user}** shared **${amount}** Cookie(s) with ${target}`
|
|
})
|
|
|
|
})
|
|
}
|
|
async function addCooldown(userId, guildId, command, subcommand, ms) {
|
|
let id = `${guildId}-${userId}-${command}-${subcommand}`
|
|
await cooldownSchema.findOneAndUpdate({
|
|
_id: id
|
|
}, {
|
|
_id: id,
|
|
command: command,
|
|
subcommand: subcommand,
|
|
cooldown: ms
|
|
}, {
|
|
upsert: true
|
|
})
|
|
}
|
|
async function leader(interaction) {
|
|
const results = await cookieSchema.find().sort({
|
|
cookies: -1
|
|
}).limit(10)
|
|
let cookieSorted = ''
|
|
let i = 0
|
|
results.forEach((result) => {
|
|
cookieSorted += `[${i + 1}] <@${result._id}> (${result.cookies})\n`
|
|
i++;
|
|
})
|
|
|
|
var embed = new Discord.MessageEmbed()
|
|
.setColor(0x0099FF)
|
|
.setThumbnail(interaction.guild.iconURL())
|
|
.setTimestamp()
|
|
.addFields({ name: `-Cookie Leaderboard-`, value: cookieSorted })
|
|
|
|
interaction.reply({
|
|
embeds: [embed]
|
|
})
|
|
}
|
|
module.exports = {
|
|
slash: true,
|
|
description: 'collect a cookie',
|
|
category: 'Misc',
|
|
options: [
|
|
//collect
|
|
{
|
|
name: "collect",
|
|
description: "want some?",
|
|
type: 1 // SubCommand Type
|
|
},
|
|
//steal
|
|
{
|
|
name: "steal",
|
|
description: "try your luck at a lala robbery!",
|
|
type: 1, // SubCommand Type
|
|
options: [
|
|
{
|
|
name: "target",
|
|
description: "someone",
|
|
required: true,
|
|
type: 6 // User Type
|
|
}
|
|
]
|
|
},
|
|
//check
|
|
{
|
|
name: "check",
|
|
description: "check your cookie stash",
|
|
required: false,
|
|
type: 1, // SubCommand Type
|
|
options: [
|
|
{
|
|
name: "target",
|
|
description: "someone",
|
|
type: 6 // User Type
|
|
}
|
|
]
|
|
},
|
|
//give
|
|
{
|
|
name: "give",
|
|
description: "share your cookies with someone",
|
|
required: false,
|
|
type: 1, // SubCommand Type
|
|
options: [
|
|
{
|
|
name: "target",
|
|
description: "someone",
|
|
required: true,
|
|
type: 6 // User Type
|
|
}, {
|
|
name: "amount",
|
|
description: "cookies",
|
|
required: true,
|
|
type: 4 // Integer Type
|
|
}
|
|
]
|
|
},
|
|
//leader
|
|
{
|
|
name: "leader",
|
|
description: "show Top 10 Cookie Clickers",
|
|
type: 1, // SubCommand Type
|
|
},
|
|
],
|
|
callback: ({ interaction, user }) => {
|
|
switch (interaction.options._subcommand) {
|
|
case "collect":
|
|
collect(interaction, user)
|
|
break;
|
|
case "steal":
|
|
steal(interaction, user)
|
|
break;
|
|
case "check":
|
|
check(interaction, user)
|
|
break;
|
|
case "give":
|
|
give(interaction, user)
|
|
break;
|
|
case "leader":
|
|
leader(interaction)
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|