WhatTheMike/Fox-V3
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/bobloy/Fox-V3

Browse Source
This commit is contained in:
Bobloy 2018-04-19 22:39:29 -04:00
commit 06bfb01fe3
12 changed files with 199 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

@ -0,0 +1,3 @@
.idea/
*.pyc

41
README.md
View File

@ -1,19 +1,32 @@
# Fox-V3
Cog Function
| Name | Status | Description
| --- | --- | --- |
| ccrole | **Beta** | Create custom commands that also assign roles |
| chatter | **Alpha** | Chat-bot trained to talk like your guild
| fight | **Incomplete** | Organize bracket tournaments within discord |
| flag | **Beta** | Create temporary marks on users that expire after specified time |
| hangman | **Incomplete** | Play a game of hangman |
| immortal | **Private** | Cog designed for a specific server, not recommended to install |
| leaver | **Incomplete** | Send a message in a channel when a user leaves the server |
| reactrestrict | **Alpha** | Removes reactions by role per channel |
| stealemoji | **Alpha** | Steals any custom emoji it sees |
| werewolf | **Incomplete** | Play the classic party game Werewolf within discord |
Cog Status
Cog Status Descriptions
- ccrole: **Incomplete** - Not yet ported to v3
- challonge: **Incomplete** - Challonge integration with discord
- chatter: **Alpha** - Train your chat-bot to talk like your guild
- fight: **Incomplete** - Still in-progress, a massive project
- flag: **Incomplete** - Not yet ported to v3
- hangman: **Incomplete** - Not yet ported to v3
- immortal: **Private** - Designed for a specific server, not recommended to install
- leaver: **Incomplete** - Not yet ported to v3
- reactrestrict: **Beta** - Removes reactions by role per channel
- stealemoji: **Alpha** - Steals any custom emoji it sees
- werewolf: **Incomplete** - Play the classic party game Werewolf within discord
Many of these are functional in my V2 cogs at [Fox-Cogs v2](https://github.com/bobloy/Fox-Cogs)
- ccrole: May have some bugs, please create an issue if you find any
- chatter: Missing some key features, but currently functional
- fight: Still in-progress, a massive project
- flag: Not yet ported to v3
- hangman: Not yet ported to v3
- immortal: Designed for a specific server, not recommended to install
- leaver: Not yet ported to v3
- reactrestrict: A bit clunky, but functional
- stealemoji: Some planned upgrades for server generation
- werewolf: Another massive project, will be fully customizable
Many of these are functional in my V2 cogs at [Fox-Cogs v2](https://github.com/bobloy/Fox-Cogs)

276
ccrole/ccrole.py
View File

@ -3,10 +3,9 @@ import asyncio
from discord.ext import commands
from redbot.core import Config
from redbot.core import Config, checks
from .utils import checks
from .utils.chat_formatting import pagify, box
from redbot.core.utils.chat_formatting import pagify, box
import os
import re
@ -19,224 +18,240 @@ class CCRole:
def __init__(self, bot):
self.bot = bot
self.file_path = "data/ccrole/commands.json"
self.c_commands = dataIO.load_json(self.file_path)
self.config = Config.get_conf(self, identifier=9999114111108101)
default_guild = {
"cmdlist" : {},
"settings": {}
}
self.config.register_guild(**default_guild)
@commands.group(pass_context=True, no_pm=True)
@commands.group(no_pm=True)
async def ccrole(self, ctx):
"""Custom commands management"""
if ctx.invoked_subcommand is None:
await self.bot.send_cmd_help(ctx)
if not ctx.invoked_subcommand:
await ctx.send_help()
@ccrole.command(name="add", pass_context=True)
@ccrole.command(name="add")
@checks.mod_or_permissions(administrator=True)
async def ccrole_add(self, ctx, command : str):
"""Adds a custom command with roles"""
command = command.lower()
if command in self.bot.commands:
await self.bot.say("That command is already a standard command.")
if command in self.bot.all_commands:
await ctx.send("That command is already a standard command.")
return
server = ctx.message.server
author = ctx.message.author
guild = ctx.guild
author = ctx.author
channel = ctx.channel
if server.id not in self.c_commands:
self.c_commands[server.id] = {}
cmdlist = self.c_commands[server.id]
if command in cmdlist:
await self.bot.say("This command already exists. Delete"
"`it with {}ccrole delete` first."
"".format(ctx.prefix))
cmdlist = self.config.guild(ctx.guild).cmdlist
if await cmdlist.get_raw(command, default=None):
await ctx.send("This command already exists. Delete it with `{}ccrole delete` first.".format(ctx.prefix))
return
# Roles to add
await self.bot.say('What roles should it add? (Must be comma separated)\nSay `None` to skip adding roles')
await ctx.send('What roles should it add? (Must be **comma separated**)\nSay `None` to skip adding roles')
answer = await self.bot.wait_for_message(timeout=120, author=author)
if not answer:
await self.bot.say("Timed out, canceling")
return
def check(m):
return m.author == author and m.channel==channel
try:
answer = await self.bot.wait_for('message', timeout=120, check=check)
except asyncio.TimeoutError:
await ctx.send("Timed out, canceling")
arole_list = []
if answer.content.upper()!="NONE":
arole_list = answer.content.split(",")
try:
arole_list = [discord.utils.get(server.roles, name=role.strip(' ')).id for role in arole_list]
except:
await self.bot.say("Invalid answer, canceling")
arole_list = await self._get_roles_from_content(ctx, answer.content)
if arole_list is None:
await ctx.send("Invalid answer, canceling")
return
# Roles to remove
await self.bot.say('What roles should it remove? (Must be comma separated)\nSay `None` to skip removing roles')
answer = await self.bot.wait_for_message(timeout=120, author=author)
if not answer:
await self.bot.say("Timed out, canceling")
return
await ctx.send('What roles should it remove? (Must be comma separated)\nSay `None` to skip removing roles')
try:
answer = await self.bot.wait_for('message', timeout=120, check=check)
except asyncio.TimeoutError:
await ctx.send("Timed out, canceling")
rrole_list = []
if answer.content.upper()!="NONE":
rrole_list = answer.content.split(",")
try:
rrole_list = [discord.utils.get(server.roles, name=role.strip(' ')).id for role in rrole_list]
except:
await self.bot.say("Invalid answer, canceling")
rrole_list = await self._get_roles_from_content(ctx, answer.content)
if rrole_list is None:
await ctx.send("Invalid answer, canceling")
return
# Roles to use
await self.bot.say('What roles are allowed to use this command? (Must be comma separated)\nSay `None` to allow all roles')
await ctx.send('What roles are allowed to use this command? (Must be comma separated)\nSay `None` to allow all roles')
answer = await self.bot.wait_for_message(timeout=120, author=author)
if not answer:
await self.bot.say("Timed out, canceling")
return
try:
answer = await self.bot.wait_for('message', timeout=120, check=check)
except asyncio.TimeoutError:
await ctx.send("Timed out, canceling")
prole_list = []
if answer.content.upper()!="NONE":
prole_list = answer.content.split(",")
try:
prole_list = [discord.utils.get(server.roles, name=role.strip(' ')).id for role in prole_list]
except:
await self.bot.say("Invalid answer, canceling")
prole_list = await self._get_roles_from_content(ctx, answer.content)
if prole_list is None:
await ctx.send("Invalid answer, canceling")
return
# Selfrole
await self.bot.say('Is this a targeted command?(yes/no)\nNo will make this a selfrole command')
await ctx.send('Is this a targeted command?(yes/no)\nNo will make this a selfrole command')
answer = await self.bot.wait_for_message(timeout=120, author=author)
if not answer:
await self.bot.say("Timed out, canceling")
return
try:
answer = await self.bot.wait_for('message', timeout=120, check=check)
except asyncio.TimeoutError:
await ctx.send("Timed out, canceling")
if answer.content.upper() in ["Y", "YES"]:
targeted = True
await self.bot.say("This command will be targeted")
await ctx.send("This command will be **`targeted`**")
else:
targeted = False
await self.bot.say("This command will be selfrole")
await ctx.send("This command will be **`selfrole`**")
# Message to send
await self.bot.say('What message should the bot send?\nSay `None` to send the default `Success!` message')
await ctx.send('What message should the bot say when using this command?\nSay `None` to send the default `Success!` message')
answer = await self.bot.wait_for_message(timeout=120, author=author)
if not answer:
await self.bot.say("Timed out, canceling")
return
try:
answer = await self.bot.wait_for('message', timeout=120, check=check)
except asyncio.TimeoutError:
await ctx.send("Timed out, canceling")
text = "Success!"
if answer.content.upper()!="NONE":
text = answer.content
# Save the command
cmdlist[command] = {'text': text, 'aroles': arole_list, 'rroles': rrole_list, "proles": prole_list, "targeted": targeted}
out = {'text': text, 'aroles': arole_list, 'rroles': rrole_list, "proles": prole_list, "targeted": targeted}
self.c_commands[server.id] = cmdlist
dataIO.save_json(self.file_path, self.c_commands)
await self.bot.say("Custom command successfully added.")
@ccrole.command(name="delete", pass_context=True)
await cmdlist.set_raw(command, value=out)
ctx.send("Custom Command **`{}`** successfully added".format(command))
@ccrole.command(name="delete")
@checks.mod_or_permissions(administrator=True)
async def ccrole_delete(self, ctx, command : str):
"""Deletes a custom command
Example:
[p]ccrole delete yourcommand"""
server = ctx.message.server
guild = ctx.guild
command = command.lower()
if server.id in self.c_commands:
cmdlist = self.c_commands[server.id]
if command in cmdlist:
cmdlist.pop(command, None)
self.c_commands[server.id] = cmdlist
dataIO.save_json(self.file_path, self.c_commands)
await self.bot.say("Custom command successfully deleted.")
else:
await self.bot.say("That command doesn't exist.")
if not await self.config.guild(ctx.guild).cmdlist.get_raw(command, default=None):
await ctx.send("That command doesn't exist")
else:
await self.bot.say("There are no custom commands in this server."
" Use `{}ccrole add` to start adding some."
"".format(ctx.prefix))
await self.config.guild(ctx.guild).cmdlist.set_raw(command, value=None)
await ctx.send("Custom command successfully deleted.")
@ccrole.command(name="list", pass_context=True)
@ccrole.command(name="list")
async def ccrole_list(self, ctx):
"""Shows custom commands list"""
server = ctx.message.server
commands = self.c_commands.get(server.id, {})
guild = ctx.guild
commands = await self.config.guild(ctx.guild).cmdlist()
if not commands:
await self.bot.say("There are no custom commands in this server."
" Use `{}ccrole add` to start adding some."
"".format(ctx.prefix))
await ctx.send("There are no custom commands in this server. Use `{}ccrole add` to start adding some.".format(ctx.prefix))
return
commands = ", ".join([ctx.prefix + c for c in sorted(commands.keys())])
commands = "Custom commands:\n\n" + commands
if len(commands) < 1500:
await self.bot.say(box(commands))
await ctx.send(box(commands))
else:
for page in pagify(commands, delims=[" ", "\n"]):
await self.bot.whisper(box(page))
await ctx.author.send(box(page))
await ctx.send("Command list DM'd")
async def on_message(self, message):
if len(message.content) < 2 or message.channel.is_private:
if len(message.content) < 2 or message.guild is None:
return
server = message.server
prefix = self.get_prefix(message)
if not prefix:
guild = message.guild
try:
prefix = await self.get_prefix(message)
except ValueError:
return
if server.id in self.c_commands and self.bot.user_allowed(message):
cmdlist = self.c_commands[server.id]
cmd = message.content[len(prefix):].split()[0]
if cmd in cmdlist:
cmd = cmdlist[cmd]
await self.eval_cc(cmd, message)
elif cmd.lower() in cmdlist:
cmd = cmdlist[cmd.lower()]
await self.eval_cc(cmd, message)
cmdlist = self.config.guild(guild).cmdlist
cmd = message.content[len(prefix):].split()[0]
cmd = await cmdlist.get_raw(cmd.lower(), default=None)
if cmd:
await self.eval_cc(cmd, message)
async def _get_roles_from_content(self, ctx, content):
content_list = content.split(",")
role_list = []
try:
role_list = [discord.utils.get(ctx.guild.roles, name=role.strip(' ')).id for role in content_list]
except:
return None
else:
return role_list
async def get_prefix(self, message: discord.Message) -> str:
"""
Borrowed from alias cog
Tries to determine what prefix is used in a message object.
Looks to identify from longest prefix to smallest.
def get_prefix(self, message):
for p in self.bot.settings.get_prefixes(message.server):
if message.content.startswith(p):
Will raise ValueError if no prefix is found.
:param message: Message object
:return:
"""
content = message.content
prefix_list = await self.bot.command_prefix(self.bot, message)
prefixes = sorted(prefix_list,
key=lambda pfx: len(pfx),
reverse=True)
for p in prefixes:
if content.startswith(p):
return p
return False
raise ValueError
async def eval_cc(self, cmd, message):
"""Does all the work"""
if cmd['proles'] and not (set(role.id for role in message.author.roles) & set(cmd['proles'])):
return # Not authorized, do nothing
if cmd['targeted']:
try:
target = discord.utils.get(message.server.members, mention=message.content.split()[1])
target = discord.utils.get(message.guild.members, mention=message.content.split()[1])
except:
target = None
if not target:
out_message = "This command is targeted! @mention a target\n`{} <target>`".format(message.content.split()[0])
await self.bot.send_message(message.channel, out_message)
await message.channel.send(out_message)
return
else:
target = message.author
if cmd['aroles']:
arole_list = [discord.utils.get(message.server.roles, id=roleid) for roleid in cmd['aroles']]
arole_list = [discord.utils.get(message.guild.roles, id=roleid) for roleid in cmd['aroles']]
# await self.bot.send_message(message.channel, "Adding: "+str([str(arole) for arole in arole_list]))
await self.bot.add_roles(target, *arole_list)
try:
await target.add_roles(*arole_list)
except discord.Forbidden:
await message.channel.send("Permission error: Unable to add roles")
await asyncio.sleep(1)
if cmd['rroles']:
rrole_list = [discord.utils.get(message.server.roles, id=roleid) for roleid in cmd['rroles']]
rrole_list = [discord.utils.get(message.guild.roles, id=roleid) for roleid in cmd['rroles']]
# await self.bot.send_message(message.channel, "Removing: "+str([str(rrole) for rrole in rrole_list]))
await self.bot.remove_roles(target, *rrole_list)
await self.bot.send_message(message.channel, cmd['text'])
try:
await target.remove_roles(*rrole_list)
except discord.Forbidden:
await message.channel.send("Permission error: Unable to remove roles")
await message.channel.send(cmd['text'])
# {'text': text, 'aroles': arole_list, 'rroles': rrole_list, "proles", prole_list, "targeted": targeted}
@ -269,23 +284,4 @@ class CCRole:
# first = objects[first]
# else:
# return raw_result
# return str(getattr(first, second, raw_result))
def check_folders():
if not os.path.exists("data/ccrole"):
print("Creating data/ccrole folder...")
os.makedirs("data/ccrole")
def check_files():
f = "data/ccrole/commands.json"
if not dataIO.is_valid_json(f):
print("Creating empty commands.json...")
dataIO.save_json(f, {})
def setup(bot):
check_folders()
check_files()
bot.add_cog(CCRole(bot))
# return str(getattr(first, second, raw_result))

5
challonge/__init__.py
View File

@ -1,5 +0,0 @@
from .challonge import Challonge
def setup(bot):
n = Challonge(bot)
bot.add_cog(n)

134
challonge/challonge.py
View File

@ -1,134 +0,0 @@
import os
import challonge
import discord
from discord.ext import commands
from redbot.core.utils.chat_formatting import pagify
from redbot.core.utils.chat_formatting import box
from redbot.core import Config
from redbot.core import checks
class Challonge:
"""Cog for organizing Challonge tourneys"""
def __init__(self, bot):
self.bot = bot
self.config = Config.get_conf(self, identifier=6710497108108111110103101)
default_global = {
"username": None,
"apikey": None
}
default_guild = {
"reportchannel": None,
"announcechannel": None
}
self.config.register_global(**default_global)
self.config.register_guild(**default_guild)
await self._set_credentials()
# ************************Challonge command group start************************
@commands.group()
@commands.guild_only()
async def challonge(self, ctx):
"""Challonge command base"""
if ctx.invoked_subcommand is None:
await ctx.send_help()
# await ctx.send("I can do stuff!")
@challonge.command(name="apikey")
async def c_apikey(self, ctx, username, apikey):
"""Sets challonge username and apikey"""
await self.config.username.set(username)
await self.config.apikey.set(apikey)
await self._set_credentials()
await ctx.send("Success!")
@challonge.command(name="report")
async def c_report(self, ctx, channel: discord.TextChannel=None):
"""Set the channel for self-reporting matches"""
if channel is None:
channel = ctx.channel
await self.config.guild(ctx.guild).reportchnnl.set(channel.id)
channel = (await self._get_reportchnnl(ctx.guild))
await ctx.send("Self-Reporting Channel is now set to: " + channel.mention)
@challonge.command(name="announce")
async def c_announce(self, ctx, channel: discord.TextChannel=None):
"""Set the channel for tournament announcements"""
if channel is None:
channel = ctx.channel
await self.config.guild(ctx.guild).announcechnnl.set(channel.id)
channel = (await self._get_announcechnnl(ctx.guild))
await ctx.send("Announcement Channel is now set to: " + channel.mention)
# ************************Private command group start************************
async def _print_tourney(self, guild: discord.Guild, tID: int):
channel = (await self._get_announcechnnl(ctx.guild))
await channel.send()
async def _set_credentials(self):
username = await self.config.username
apikey = await self.config.apikey
if username and apikey:
challonge.set_credentials(username, apikey)
return True
return False
async def _get_message_from_id(self, guild: discord.Guild, message_id: int):
"""
Tries to find a message by ID in the current guild context.
:param ctx:
:param message_id:
:return:
"""
for channel in guild.text_channels:
try:
return await channel.get_message(message_id)
except discord.NotFound:
pass
except AttributeError: # VoiceChannel object has no attribute 'get_message'
pass
return None
async def _get_announcechnnl(self, guild: discord.Guild):
channelid = await self.config.guild(guild).announcechnnl()
channel = self._get_channel_from_id(channelid)
return channel
async def _get_reportchnnl(self, guild: discord.Guild):
channelid = await self.config.guild(guild).reportchnnl()
channel = self._get_channel_from_id(channelid)
return channel
def _get_channel_from_id(self, channelid):
return self.bot.get_channel(channelid)
def _get_user_from_id(self, userid):
# guild = self._get_guild_from_id(guildID)
# return discord.utils.get(guild.members, id=userid)
return self.bot.get_user(userid)
def _get_guild_from_id(self, guildID):
return self.bot.get_guild(guildID)

10
challonge/info.json
View File

@ -1,10 +0,0 @@
{
"author" : ["Bobloy"],
"bot_version" : [3,0,0],
"description" : "[Incomplete] Cog to organize tournaments within Discord using Challonge",
"hidden" : false,
"install_msg" : "Thank you for installing the Challonge Cog.",
"requirements" : ["iso8601", "challonge"],
"short" : "[Incomplete] Cog to organize Challonge tournaments",
"tags" : ["game", "fun", "fight", "tournament", "tourney", "challonge", "elimination", "bracket", "bobloy"]
}

38
werewolf/builder.py
View File

@ -2,7 +2,6 @@ import asyncio
import discord
# Import all roles here
from werewolf.role import Role
from werewolf.roles.vanillawerewolf import VanillaWerewolf
from werewolf.roles.villager import Villager
from werewolf.roles.seer import Seer
@ -10,39 +9,44 @@ from werewolf.roles.seer import Seer
# All roles in this list for iterating
role_list = [Villager, VanillaWerewolf]
#Example code:
# 0 = Villager
# 1 = VanillaWerewolf
# E1 = Random Town
# R1 = Random Werewolf
# J1 = Benign Neutral
"""
Example code:
0 = Villager
1 = VanillaWerewolf
E1 = Random Town
R1 = Random Werewolf
J1 = Benign Neutral
# 0001-1112E11R112P2
# 0,0,0,1,11,12,E1,R1,R1,R1,R2,P2
0001-1112E11R112P2
0,0,0,1,11,12,E1,R1,R1,R1,R2,P2
pre-letter = exact role position
double digit position preempted by `-`
"""
# pre-letter = exact role position
# double digit position pre-empted by `-`
async def parse_code(code):
"""Do the magic described above"""
out = []
#Do the magic described above
decode = code.copy() # for now, pass exact names
for role_id in decode:
print(role_id)
if role_id == "Villager":
role = Villager
if role_id == "VanillaWerewolf":
elif role_id == "VanillaWerewolf":
role = VanillaWerewolf
if role_id == "Seer":
elif role_id == "Seer":
role = Seer
else: # Fail to parse
return None
out.append(role)
return out
async def build_game(channel: discord.TextChannel):
await channel.send("Not currently available")
code = 12345678
await channel.send("Your game code is **`{}`**".format(code))

14
werewolf/game.py
View File

@ -1,8 +1,6 @@
import asyncio
import discord
from datetime import datetime, timedelta
import random
from werewolf.player import Player
@ -14,7 +12,7 @@ class Game:
"""
Base class to run a single game of Werewolf
"""
default_secret_channel = {
"channel": None,
"players": [],
@ -59,10 +57,7 @@ class Game:
self.vote_groups = {} # ID : VoteGroup()
self.night_results = []
self.loop = asyncio.get_event_loop()
async def setup(self, ctx):
@ -91,7 +86,8 @@ class Game:
self.guild.me: discord.PermissionOverwrite(read_messages=True, send_messages=True)
}
self.channel_category = await self.guild.create_category("ww-game", overwrites=overwrite, reason="New game of werewolf")
self.channel_category = await self.guild.create_category("ww-game", overwrites=overwrite, reason="New game of "
"werewolf")
for player in self.players:
overwrite[player.member] = discord.PermissionOverwrite(read_messages=True)
@ -145,7 +141,7 @@ class Game:
"""
await self._at_day_start()
# Once cycle ends, this will trigger end_game
await self._end_game() # Handle open channels
await self._end_game() # Handle open channels
async def _at_game_start(self): # ID 0
if self.game_over:

2
werewolf/player.py
View File

@ -1,8 +1,6 @@
import asyncio
import discord
from datetime import datetime, timedelta
class Player:
"""

1
werewolf/role.py
View File

@ -1,5 +1,6 @@
import asyncio
class Role:
"""
Base Role class for werewolf game

4
werewolf/roles/seer.py
View File

@ -97,12 +97,12 @@ class Seer(Role):
# async def _at_day_end(self):
# pass
async def _at_night_start(self):
async def _at_night_start(self, data=None):
await self.game.generate_targets(self.player.member)
await self.player.send_dm("{}\n**Pick a target to see tonight**\n")
async def _at_night_end(self):
async def _at_night_end(self, data=None):
target = await self.game.visit(self.see_target)
alignment = None

11
werewolf/werewolf.py
View File

@ -5,8 +5,6 @@ from discord.ext import commands
from redbot.core import Config
from datetime import datetime, timedelta
from werewolf.game import Game
@ -48,9 +46,8 @@ class Werewolf:
await ctx.send("Failed to start a new game")
else:
await ctx.send("New game has started")
@commands.guild_only()
@commands.guild_only()
@ww.command()
async def join(self, ctx):
"""
@ -140,7 +137,7 @@ class Werewolf:
await game.vote(ctx.author, id, channel)
else:
await ctx.send("Nothing to vote for in this channel")
@ww.command()
async def choose(self, ctx, data):
"""
@ -157,7 +154,7 @@ class Werewolf:
# If multiple games, panic
for game in self.games.values():
if await game.get_player_by_member(ctx.author):
break #game = game
break # game = game
else:
await ctx.send("You're not part of any werewolf game")
return