async def recieve_block(self, request):
"""Verifing and adding to the blockchain, which mined by other client. """
""" If client not set up."""
if self.client.public_key == None:
response = {'message': 'No client setup.'}
return web.json_response(data=response, status=400)
result = await request.json()
if not result:
response = {'message': 'No data found.'}
return web.json_response(data=response, status=400)
block = Block(result['index'], result['preveous_hash'], [
Vote(vt['candidate'], vt['id'], vt['node'], vt['signature'])
for vt in result['votes']
], result['proof'], result['timestamp'])
block = self.blockchain.mine_by_other_client(block)
if block is False:
response = {'message': 'Corrapted block.'}
return web.json_response(data=response, status=400)
elif not block is None:
response = {
'message': 'Add the Block done.',
'block': Block.to_order_dict(block)
}
return web.json_response(data=response, status=201)
else:
response = {
'message': 'Adding the block failed. No client set up.'
}
return web.json_response(data=response, status=500)
def tally():
votes = Vote()
data = votes.tally()
response = app.response_class(response=json.dumps(data),
status=200,
mimetype='application/json')
return response
def vote():
data = request.json
x = {'submission': 'successful'}
response = app.response_class(response=json.dumps(data),
status=200,
mimetype='application/json')
vote = Vote()
vote.cast(data['session'], data['email'], data['framework'])
return response
def getVote():
connection = mysql.connector.connect(user=os.getenv("DB_USER"),
password=os.getenv("DB_PASS"),
host=os.getenv("DB_HOST"),
database=os.getenv("DB_NAME"))
cursor = connection.cursor()
vote = Vote(connection, cursor)
voteKey = request.form.get('vote')
response = make_response(str(vote.retrieveVote(voteKey))[2:-1])
response.headers.add('Access-Control-Allow-Origin', '*')
connection.close()
return response
def load_votes(csv_file=CSVFILE):
'''Read a csv file - each line is a vote, return a list of votes'''
myvotes = []
try:
#with open(csv_file, 'rb') as f:
with open(csv_file, 'rU') as f:
reader = csv.reader(f)
for row in reader:
newvote = Vote(row)
myvotes.append(newvote)
except Exception, e:
raise
def vote():
with app.app_context():
db = get_db()
cur = db.cursor()
cur.execute('SELECT * FROM crobdidates WHERE writein = ?', (False, ))
crobdidates = []
for row in cur.fetchall():
print(row)
crobdidates.append(
Vote(row[0], row[1], row[2], row[3], row[4], row[5]))
return render_template('vote.html', crobdidates=crobdidates)
return render_template('home.html')
async def add_vote(self, candidate, id, signature=0):
""" If the public key of client not exist """
if self.hosting_node == None:
return False
vote = Vote(candidate, id, node=self.hosting_node, signature=signature)
self.__open_votes.append(vote)
if self.send_vote(vote):
print('Vote send.')
else:
print('Vote send failed.')
return True
async def vote_mute_user(ctx, user: discord.Member):
# check if there is already a vote in progress
global vote
if vote.active:
response = f"Sorry {ctx.message.author.mention}, a vote is already in progress."
else:
voters = get_voters(ctx.guild)
vote = Vote(voters, user)
vote.activate() # start vote
response = f"{ctx.message.author.nick} has started a vote to server mute {user.display_name}. The current " \
f"voters are:\n"
response += "\n".join(v.display_name for v in voters)
await ctx.send(response)
def load_data():
try:
with open('db/blockchain.txt', mode = 'r') as f:
file_contents = f.readlines()
""" Read blockchain form the file"""
blockchain = json.loads(file_contents[0][:-1])
updated_blockchain = []
for block in blockchain:
for vt in block['votes']:
print(vt)
converted_vt = [Vote(vt['candidate'], vt['id']) for vt in block['votes']]
updated_block = Block(block['index'], block['preveous_hash'], converted_vt, block['proof'], block['timestamp'])
updated_blockchain.append(updated_block)
blockchain = updated_blockchain
""" Read open votes form the file"""
open_votes = json.loads(file_contents[1])
updated_votes = []
for vt in open_votes:
updated_vote = Vote(vt['candidate'], vt['id'])
updated_votes.append(updated_vote)
open_votes = updated_votes
return blockchain, open_votes
except(IOError, IndexError):
print('Load data Failed!!!!!!')
return None, None
finally:
print('clean up')
def get_vote(self,
rm='',
hangar_id='',
bet='',
punkt='',
parti='',
valkrets='',
rost='',
antal=500,
gruppering=''):
data = self._get(
self.url, 'voteringlista', {
'hangar_id': hangar_id,
'rm': rm,
'bet': bet,
'punkt': punkt,
'parti': parti,
'valkrests': valkrets,
'iid': '',
'rost': rost,
'sz': antal,
'utformat': 'json',
'gruppering': gruppering,
})
vote_list = []
if data['@antal'] == '0':
logging.warning(f'No data for.')
elif data['@antal'] == '1':
vote_list.append(Vote(data['votering']))
else:
for vote_data in data['votering']:
vote_list.append(Vote(vote_data))
return vote_list
def postVote():
connection = mysql.connector.connect(user=os.getenv("DB_USER"),
password=os.getenv("DB_PASS"),
host=os.getenv("DB_HOST"),
database=os.getenv("DB_NAME"))
cursor = connection.cursor()
vote = Vote(connection, cursor)
voterKey = request.form.get('voter')
electionKey = request.form.get('election')
candidateKey = request.form.get('candidate')
response = make_response(
str(vote.generateVote(electionKey, voterKey, candidateKey)))
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
connection.close()
return response
def vote(poll_code):
# 1. get poll
poll = Poll.objects(
code=poll_code).first() # .first la lay phan tu dau tien
if request.method == 'GET':
# 2. render poll detail + input
return render_template("vote.html", p=poll)
# 3. handle form request (POST)
elif request.method == 'POST':
form = request.form
name = form['voter']
choice = form['choice']
#vote = form['vote']
# 4. Save
new_vote = Vote(name=name, choice=choice, poll=poll)
new_vote.save()
return "Voted"
def main():
if len(sys.argv) < 2:
print('Usage: {} file'.format(sys.argv[0]))
sys.exit(1)
client = DBClient('votes', 'example')
client.drop()
file = open(sys.argv[1])
for line in file.readlines():
fields = [f.strip() for f in line.strip().split(',')]
if not fields[-1]:
continue
vote = Vote(fields[0], fields[1], fields[2], fields[3], fields[4], '',
'')
pprint(vote.to_dictionary())
client.insert_one(vote.to_dictionary())
print(client.count())
def read_files(self):
"""
Reads JSON paths of Reps, Bills, and Votes
"""
print('Loading sessions.')
ses_paths = get_jsons(Session.ROOT_DIR)
self._sessions = [Session(filename=p) for p in tqdm(ses_paths)]
print('Loading reps.')
rep_paths = get_jsons(Representative.ROOT_DIR)
self._reps = [Representative(filename=p) for p in tqdm(rep_paths)]
print('Loading bills.')
bill_paths = get_jsons(Bill.ROOT_DIR)
self._bills = [Bill(filename=p) for p in tqdm(bill_paths)]
print('Loading votes.')
vote_paths = get_jsons(Vote.ROOT_DIR)
self._votes = [Vote(filename=p) for p in tqdm(vote_paths)]
def count_vote():
if 'candidate' in request.form and request.form['candidate'] != "-1":
print('standard candidates selected')
print(str(request.form['candidate']))
with app.app_context():
db = get_db()
cur = db.cursor()
c = int(request.form['candidate'])
cur.execute('SELECT * FROM crobdidates WHERE id = ?', (c, ))
result = cur.fetchone()
print(str(result))
newvotes = int(result[5]) + 1
cur.execute('UPDATE crobdidates SET votes = ? WHERE id = ?',
(newvotes, int(request.form['candidate'])))
db.commit()
elif 'writein' in request.form and request.form['writein']:
print('writein candidate selected!')
print(request.form['writein'])
with app.app_context():
db = get_db()
cur = db.cursor()
cur.execute('SELECT * FROM crobdidates WHERE prez = ?',
(request.form['writein'], ))
result = cur.fetchone()
if not result:
cur.execute(
'INSERT INTO crobdidates (prez, vprz, slogan, writein, votes) VALUES (?, ?, ?, ?, ?)',
(request.form['writein'], "", "", True, 1))
else:
cur.execute('UPDATE crobdidates SET votes = ? WHERE id = ?',
(int(result[5]) + 1, int(result[0])))
db.commit()
data = []
with app.app_context():
db = get_db()
cur = db.cursor()
cur.execute('SELECT * FROM crobdidates ORDER BY votes DESC')
for row in cur.fetchall():
data.append(Vote(row[0], row[1], row[2], row[3], row[4], row[5]))
# print(str(data))
graph_file = render_graph(data)
return render_template('results.html', graph_file=graph_file, data=data)
async def createvote(self, ctx: Context, votename: str):
if dm.vote_exists(votename):
await ctx.send("Vote with that name already exists!")
return
def check(m):
return m.author.id == ctx.author.id and m.channel == ctx.channel
await ctx.send("Send line separated choices")
options: str
try:
options = await self.bot.wait_for("message", check=check, timeout=90)
except asyncio.TimeoutError:
ctx.send("Timed out")
return
options = options.content.split("\n")
dm.create_vote(Vote(votename, options))
await ctx.send("Vote created successfully")
async def receive_vote(self, request):
""" Recieving the vote form another client."""
""" If client not set up."""
if self.client.public_key == None:
response = {'message': 'No client setup.'}
return web.json_response(data=response, status=400)
result = await request.json()
if not result:
response = {'message': 'No data found.'}
return web.json_response(data=response, status=400)
vote = Vote(result['candidate'], result['id'], result['node'],
result['signature'])
if self.client.verify_vote(vote):
self.blockchain.add_to_open_votes(vote)
response = {'message': 'Recieved succed.'}
return web.json_response(data=response, status=200)
else:
response = {'message': 'Corrapted vote.'}
return web.json_response(data=response, status=400)
async def add_vote(self, request):
"""If the client machine not create a keys."""
if self.client.public_key == None:
response = {'message': 'No client set up.'}
return web.json_response(data=response, status=400)
"""If user are not login."""
if self.user.user is None:
response = {'message': 'User are not Login.'}
return web.json_response(data=response, status=400)
"""If the request has not data."""
values = await request.json()
if not values:
response = {'message': 'No data found.'}
return web.json_response(data=response, status=400)
"""If the required data has an missing. """
required_fields = ['candidate', 'id']
if not all(field in values for field in required_fields):
response = {'message': 'Required data missing.'}
return web.json_response(data=response, status=400)
candidate = values['candidate']
vote = Vote(candidate)
vote.signature = self.client.sign_vote(candidate, vote.id)
vote.node = self.client.public_key
success = await self.blockchain.add_to_open_votes(vote)
"""if the system add vote successflly."""
if success:
response = {
'message': 'Successfully added vote.',
'vote': {
'candidate': candidate,
'id': vote.id,
'node': self.client.public_key,
'signature': vote.signature
}
}
return web.json_response(data=response, status=201)
else:
response = {'message': 'creating a vote failed.'}
return web.json_response(data=response, status=500)
async def vote(self, ctx: Context, *choices: str, time=20):
""" Create a vote. (Alt command: v) """
# Check if voting is possible
guild = ctx.guild
if ctx.guild is None:
await ctx.send("This feature is only supported in guilds")
return
vote = self.votes.get(guild)
if vote:
await ctx.send("There is already a vote running")
return
# Attach a number to each choice
choice_enum: List[Tuple[int, str]] = list(
enumerate(
map(lambda choice: choice.strip(" ,\n").lower(), choices), 1))
vote = Vote(self.bot, guild, choice_enum)
self.votes[guild] = vote
LOGGER.debug("Started voting listener")
self.bot.add_listener(vote.on_vote, name="on_message")
choice_text = ("\n".join(
map(lambda choice: f"{choice[0]}\t\u21D2 \t{choice[1]}",
choice_enum)) if choice_enum else "Open voting")
await ctx.send(f"Voting started for {time}s.\n{choice_text}")
await asyncio.sleep(time)
self.bot.remove_listener(vote.on_vote, name="on_message")
LOGGER.debug("Removed voting listener")
results = vote.format_results()
hist = vote.termogram()
if hist is not None:
await ctx.send(f"Voting finished!\n{hist}")
else:
await ctx.send(f"Voting finished!\n{results}")
del self.votes[guild]
async def replace_chain(self):
""" Replacing chian, Using longest chain Algorithm."""
network = self.nodes_url
max_length = 0
longest_chain = None
""" Longest chain """
for node in network:
new_chain = []
response = requests.get(f'http://{node}/chain')
response = None
status_code = None
# response = requests.get(f'http://{node}/chain')
async with aiohttp.ClientSession() as session:
async with session.get(f'http://{node}/chain') as resp:
status_code = resp.status
response = await resp.json()
if status_code == 200:
length = response['length']
chain = response['chain']
for block in chain:
# added_block = Block(block['index'], block['preveous_hash'],[vt.__dict__ for vt in block['votes']], block['proof'], block['timestamp'])
added_block = Block(block['index'], block['preveous_hash'],
[
Vote(vt['candidate'], vt['id'],
vt['node'], vt['signature'])
for vt in block['votes']
], block['proof'], block['timestamp'])
new_chain.append(added_block)
if self.verify_other_chain(new_chain) and length > max_length:
longest_chain = new_chain
max_length = length
if longest_chain:
print(max_length)
self.__chain = longest_chain
return True
return False
p21 = {1: 80, 2: 20}
p22 = {1: 80, 2: 20}
p23 = {1: 80, 2: 20}
p24 = {1: 90, 2: 10}
p25 = {1: 90, 2: 10}
p26 = {1: 90, 2: 10}
p27 = {1: 90, 2: 10}
p28 = {1: 90, 2: 10}
p29 = {1: 90, 2: 10}
p30 = {1: 90, 2: 10}
p31 = {1: 90, 2: 10}
p32 = {1: 90, 2: 10}
p33 = {1: 90, 2: 10}
# Votes
v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 = Vote(2, p1), Vote(2, p2), Vote(
2, p3), Vote(2, p4), Vote(2,
p5), Vote(2, p6), Vote(2, p7), Vote(2, p8), Vote(
2, p9), Vote(2, p10), Vote(2, p11)
v12, v13, v14, v15, v16, v17, v18, v19, v20 = Vote(1, p12), Vote(1, p13), Vote(
1,
p14), Vote(1,
p15), Vote(1,
p16), Vote(1,
p17), Vote(1,
p18), Vote(1,
p19), Vote(1, p20)
v21, v22, v23, v24, v25, v26, v27, v28, v29 = Vote(1, p21), Vote(1, p22), Vote(
1,
p23), Vote(1,
p24), Vote(1,
# app.py
from flask import Flask, request, jsonify
from flask_cors import CORS
from vote import Vote
app = Flask(__name__)
CORS(app)
vote = Vote({
"options": [],
"voters": [],
"missing": [],
"complete": [],
})
@app.route('/getVote/', methods=['GET'])
def getConfigurations():
return jsonify(vote.toJson())
@app.route('/getVote/', methods=['POST'])
def getConfigurations():
return jsonify(vote.toJson())
if __name__ == '__main__':
# Threaded option to enable multiple instances for multiple user access support
app.run(host="192.168.1.9", threaded=True, port=5050)
import json
import discord
from discord.ext import commands
from vote import Vote
from time import sleep
with open('secrets.json') as file:
data = json.load(file)
TOKEN = data['bot_token']
intents = discord.Intents.all()
bot = commands.Bot(command_prefix='!', intents=intents)
# bot = commands.Bot(command_prefix='!')
vote = Vote(None, None)
@bot.event
async def on_ready():
print(f'{bot.user} has connected to Discord!')
@bot.command(name='mutenicko')
async def mutenicko(ctx):
response = "mute nicko :^)"
await ctx.send(response)
@bot.command(name='mute')
# @commands.has_permissions(mute_members=True)
async def mute_user(ctx, user: discord.Member):
def add_vote(self, name, text, vars):
self.votes[name] = Vote(name, text, vars)
def setUp(self):
self.client = Redis(decode_responses=True)
self.client.flushdb()
self.vote = Vote(self.client, "question::10086")
from flask import Flask, request, make_response, Response
import json
from collections import defaultdict
from tokens import SLACK_BOT_TOKEN, SLACK_VERIFICATION_TOKEN
from slackclient import SlackClient
from vote import Vote
from ask import Ask
slack_client = SlackClient(SLACK_BOT_TOKEN)
app = Flask(__name__)
feedback_id = 0
vote_id = 0
asker = Ask()
voter = Vote()
slasher = {asker.command: asker, voter.command: voter}
#TODO: Add checks for all responses from slack api calls
store = {}
# converted to following structure for multi user answering support
# dict store
# top level: per question/command (callback_id)
# users: list
# counter: defaultdict(int)
# ques_ts: public message_ts
# admin_ts: admin message_ts
# EXAMPLE:
# store = {"feedback1": {"users": [], "counter": defaultdict(int), "ques_ts": "1503435956.000247", "admin_ts": "1503484268.000285"}}
def openVote(self):
self.window = QtWidgets.QMainWindow()
self.ui = Vote()
self.ui.setupUi(self.window)
self.window.show()
MainWindow.hide()
async def on_reaction_add(self, reaction, user):
if user == client.user:
return
self.react_channel = reaction.message.channel
if reaction.message.content[:
19] == "**Join weerwolfen**" and reaction.emoji == "🐺" and reaction.message.author.bot:
await user.add_roles(self.weerwolfen_spel_rol)
# cupido
if self.react_channel.name == "cupido" and self.gameloop_currentrol == "cupido":
self.cupido_vote.vote[reaction] = 1
if len(
self.cupido_vote.vote
) == 2: # look for 2 reactions and they should have a count of 2
await self.cupido_vote.cupido(channel=self.geliefde_channel)
del self.cupido_vote
await reaction.message.delete()
# we gaan nu naar ziener
self.gameloop_currentrol = "ziener"
await self.het_plein_channel.send(
"De ziener wordt wakker en bekijkt iemands persoonlijkheid"
)
self.ziener_vote = Vote(
message_text="Wie wil de ziener bekijken",
speler_lijst=self.players_levend_list,
channel=self.ziener_channel)
await self.ziener_vote.send_message()
# Ziener
if self.react_channel.name == "ziener" and self.gameloop_currentrol == "ziener":
print("go go go")
await self.ziener_vote.ziener(reaction=reaction)
del self.ziener_vote
await reaction.message.delete()
# we gaan nu over naar weerwolfen
self.gameloop_currentrol = "weerwolf"
await self.het_plein_channel.send(
"De weerwolfen worden wakker opzoek naar een midnight snack")
self.weerwolfen_vote = Vote(
message_text="Wie gaan julie opeten",
speler_lijst=[
speler for speler in self.players_levend_list
if speler.rol_display_name != "Weerwolf"
and speler.levend == True
],
channel=self.weerwolfen_channel,
action_message="{} is opgegeten")
await self.weerwolfen_vote.send_message()
self.killed = []
# weerwolfen
if self.react_channel.name == "weerwolfen" and self.gameloop_currentrol == "weerwolf":
self.killed.append(
await self.weerwolfen_vote.normal_action(reaction=reaction))
del self.weerwolfen_vote
await reaction.message.delete()
# begin met Heks
self.gameloop_currentrol = "heks"
self.heks_response = 0
if self.levendrankje == True or self.dooddrankje == True:
await self.het_plein_channel.send("De heks wordt wakker")
if self.levendrankje:
self.heks_leven_vote = Vote(
message_text=
"**Levensdrankje**\n{} is dood wil je hem/haar redden".
format(self.killed[0].name),
speler_lijst=("Nee", "Ja"),
channel=self.heks_channel)
await self.heks_leven_vote.send_message()
else:
self.heks_response += 1
if self.dooddrankje:
heks_lijst = [i for i in self.players_levend_list]
heks_lijst.append("**NIEMAND**")
self.heks_dood_vote = Vote(
message_text=
"**Dodendrankje**\nWil je iemand vermoorden",
speler_lijst=heks_lijst,
channel=self.heks_channel,
action_message="Je hebt {} vergiftigt")
await self.heks_dood_vote.send_message()
else:
self.heks_response += 1
else:
await self.het_plein_channel.send("De heks kan niks meer doen")
await self.switch_to_day()
# Heks
if self.react_channel.name == "heks" and self.gameloop_currentrol == "heks":
if "Dodendrankje" in reaction.message.content:
self.heks_response += 1
gebruikt = await self.heks_dood_vote.normal_action(
reaction=reaction)
self.killed.append(gebruikt)
del self.heks_dood_vote
await reaction.message.delete()
if gebruikt != "**NIEMAND**":
self.dooddrankje = False
if "Levensdrankje" in reaction.message.content:
self.heks_response += 1
keuze = self.heks_leven_vote.heks_leven(reaction=reaction)
del self.heks_leven_vote
await reaction.message.delete()
if keuze == "Ja":
await reaction.message.channel.send(
"Je hebt {} weer tot leven gewekt".format(
self.killed[0].name))
self.killed.remove(self.killed[0])
self.levendrankje = False
else:
return
if self.heks_response == 2:
# Ga naar dag
try:
self.killed.remove("**NIEMAND**")
except:
pass
for speler in [i for i in self.killed]:
if speler.in_love:
await self.het_plein_channel.send(embed=discord.Embed(
description=
"{} was instens verlieft op {} en pleegt zelfmoord"
.format(speler.in_love.name, speler.name),
colour=discord.Colour(value=16732324)))
self.killed.append(speler.in_love)
if len(self.killed) > 1:
await reaction.message.channel.send(
"{} zijn gestorven deze nacht".format(" en ".join(
[str(speler.name) for speler in self.killed])))
if len(self.killed) == 1:
await reaction.message.channel.send(
"{} is gestorven deze nacht".format("".join(
[str(speler.name) for speler in self.killed])))
jager = [
speler for speler in self.killed
if speler.rol_display_name == "Jager"
]
if len(jager) == 1:
jager = jager[0]
self.gameloop_currentrol = "jager"
await self.het_plein_channel.send(
"{} is de jager hij kiest nu wie hij wil vermoorden".
format(jager.name))
self.jager_vote = Vote(
message_text="Wie wil je doodschieten",
speler_lijst=[
i for i in self.players_levend_list
if i not in self.killed
],
channel=self.jager_channel,
action_message="{} is doodgeschoten")
await self.jager_vote.send_message()
else:
await self.switch_to_day()
if self.react_channel.name == "jager" and self.gameloop_currentrol == "jager":
self.killed.append(await
self.jager_vote.normal_action(reaction=reaction
))
del self.jager_vote
await reaction.message.delete()
await self.switch_to_day()
async def on_message(self, message):
# dit triggert als er een message komt
self.server = message.guild # van welke server kwam de message
self.bericht_text = message.content.split() # split de bericht text
if message.author != client.user: # check of auteur niet bot is zodat je niet dood gespamt wordt
self.bericht_text = message.content.split()
# Add text channels
if self.bericht_text[0] == "!init":
self.join_message = False
# if self.init == True:
# return
# self.init = True
self.weerwolfen_spel_rol = await self.server.create_role(
name="spel Weerwolfen", mentionable=True)
self.weerwolfen_category = await self.server.create_category(
"Weerwolfen")
self.het_plein_channel = await self.server.create_text_channel(
"Het plein", category=self.weerwolfen_category)
self.cupido_channel = await self.server.create_text_channel(
"Cupido", category=self.weerwolfen_category)
self.ziener_channel = await self.server.create_text_channel(
"Ziener", category=self.weerwolfen_category)
self.weerwolfen_channel = await self.server.create_text_channel(
"Weerwolfen", category=self.weerwolfen_category)
self.heks_channel = await self.server.create_text_channel(
"Heks", category=self.weerwolfen_category)
self.geliefde_channel = await self.server.create_text_channel(
"Geliefde chat", category=self.weerwolfen_category)
self.jager_channel = await self.server.create_text_channel(
"Jager", category=self.weerwolfen_category)
# voice
self.dag_channel = await self.server.create_voice_channel(
"🌞 Dag", category=self.weerwolfen_category)
self.nacht_channel = await self.server.create_voice_channel(
"🌙 Nacht", category=self.weerwolfen_category)
self.channel_dict = {
"Het plein:": self.het_plein_channel,
"Cupido": self.cupido_channel,
"Ziener": self.ziener_channel,
"Weerwolf": self.weerwolfen_channel,
"Heks": self.heks_channel,
"Geliefde": self.geliefde_channel,
"Jager": self.jager_channel,
"Dag": self.dag_channel,
"Nacht": self.nacht_channel
}
self.dood_rol = await self.server.create_role(name="Dood",
mentionable=True)
# set permissions op de channels
for i in self.weerwolfen_category.channels:
await i.set_permissions(target=self.server.default_role,
read_messages=False)
await self.het_plein_channel.set_permissions(
target=self.weerwolfen_spel_rol,
send_messages=True,
read_messages=True)
await self.dag_channel.set_permissions(
target=self.weerwolfen_spel_rol,
connect=False,
speak=True,
use_voice_activation=True,
read_messages=True)
# Start commando
print(message.content)
if self.bericht_text[0] == "!start":
self.player_lijst = []
for member in self.weerwolfen_spel_rol.members:
self.player_lijst.append(Player(member))
shuffle(self.player_lijst)
self.players_levend_list = [
i for i in self.player_lijst if i.levend
]
self.player_hoeveelheid = len(self.player_lijst)
if self.player_hoeveelheid < 6:
await message.channel.send(
"Te weinig spelers doen mee.\nGeef meer leden de Weerwolf spel rol"
)
return
self.rollen_lijst = await self.get_game_rollen(
self.player_hoeveelheid)
if len(self.rollen_lijst) == self.player_hoeveelheid:
for speler, rol in zip(self.player_lijst,
self.rollen_lijst):
speler.rol = rol # Doe rol object in de player class
await speler.member.add_roles(
rol) # Voeg rol toe aan member
speler.rol_display_name = rol.name # Voeg display name toe aan member
await rol.edit(name=id_generator()
) # Verander rol naam in random string
# await message.channel.send(str(speler))
if not speler.member.bot and self.bericht_text[
1] != "no": # Als speler niet bot stuur dan bericht met info
await speler.member.send(
delete_after=30,
embed=discord.Embed(
description="You are {}".format(
speler.rol_display_name),
colour=discord.Colour(value=1412412)))
for i in self.player_lijst:
if i.rol_display_name == "Burger":
continue
await self.channel_dict[i.rol_display_name
].set_permissions(
target=i.rol,
read_messages=True,
send_messages=True)
if i.rol_display_name == "Weerwolf":
await self.nacht_channel.set_permissions(
target=i.rol,
read_messages=True,
connect=True,
speak=True,
use_voice_activation=True)
# Eerste nacht
self.gameloop_currentrol = "cupido"
# heks stuff
self.levendrankje = True
self.dooddrankje = True
self.dag = 1
await self.het_plein_channel.send(
"Het is nacht cupido wordt wakker en wijst 2 geliefde aan"
)
self.cupido_vote = Vote(
message_text="Cupido wijst 2 gelefde aan",
speler_lijst=self.player_lijst,
channel=self.cupido_channel)
await self.cupido_vote.send_message()
return
# !Clean
if self.bericht_text[0] == "!clean":
await self.clean()
#!vote
if self.bericht_text[
0] == "!stem" and message.channel.name == "het-plein" and self.gameloop_currentrol == "burgermeester":
if len(self.bericht_text) == 1:
await message.delete()
return
stem = self.return_member(mention=self.bericht_text[1])
if message.author == stem:
await message.delete()
await self.het_plein_channel.send(
"{} Je kan niet op jezelf stemmen".formate(
message.author.mention),
delete_after=4)
return
if not isinstance(stem, discord.Member):
await message.delete()
return
if stem not in self.players_levend_list_members:
await message.channel.send(
"Je kan niet op iemand stemmen die dood is",
delete_after=4)
await message.delete()
return
self.stemming[message.author] = self.bericht_text[
1] # Zet autor in de dict
stemming_resultaat = {}
for i in list(self.stemming.items()
): # zet alle votes in de nieuwe dict tot 1
stemming_resultaat[i[1]] = 0
for i in list(self.stemming.items()
): # plus 1 voor elke keer dat vote voorkomt
stemming_resultaat[i[1]] += 1
output = []
for i in list(stemming_resultaat.items()):
if i[1] == 1:
output.append("{} stem voor {} ".format(i[1], i[0]))
else:
output.append("{} stemmen voor {} ".format(i[1], i[0]))
output.sort()
await self.stemming_bericht.edit(
content=
"@here nu gaan we stemmen op wie burgermeester moet worden\n\nStemming:\n{}"
.format("\n".join(output)))
if len(self.stemming) == 2: #self.players_levend:
hoogste = (None, -1) # maak lege hoogste
for i in list(stemming_resultaat.items()):
if i[1] > hoogste[
1]: # vergelijk de stemmen van die user met de hoogste stemmen
hoogste = i #evalutionaire algoritme??
if list(stemming_resultaat.values()).count(
hoogste[1]
) > 1: # als stemming meer and 1 keer voor komt
await self.stemming_bericht.edit(
content=
"@here nu gaan we stemmen op wie burgermeester moet worden\n\nStemming:\n{}\n\nHet staat momenteel gelijk"
.format("\n".join(output)))
await message.delete()
return
else:
winning_player = next(
(player for player in self.player_lijst
if player.name == self.return_member(
mention=hoogste[0]).name))
winning_player.burgermeester = True
self.burgermeester = winning_player.member
self.stemming = {}
self.gameloop_currentrol = "stemming"
await message.delete()
await self.stemming_bericht.delete()
await self.het_plein_channel.send(embed=discord.Embed(
description="{} heeft gewonnen en is burgermeester"
.format(hoogste[0],
colour=discord.Colour(value=2195054))))
self.stemming_bericht = await self.het_plein_channel.send(
"@here We gaan nu stemmen op de persoon die wordt vermoord\n\nStemming:"
)
else:
await message.delete()
# nu moet de hele vote nog een keer voor wie er dood moet je boy stem
if self.bericht_text[
0] == "!stem" and message.channel.name == "het-plein" and self.gameloop_currentrol == "stemming":
if len(self.bericht_text) == 1:
await message.delete()
return
stem = self.return_member(mention=self.bericht_text[1])
if message.author == stem:
await message.delete()
await self.het_plein_channel.send(
"{} Je kan niet op jezelf stemmen".format(
message.author.mention),
delete_after=4)
return
if not isinstance(stem, discord.Member):
await message.delete()
return
if stem not in self.players_levend_list_members:
await message.channel.send(
"Je kan niet op iemand stemmen die dood is",
delete_after=4)
await message.delete()
return
self.stemming[message.author] = self.bericht_text[
1] # Zet autor in de dict
stemming_resultaat = {}
for i in list(self.stemming.items()
): # zet alle votes in de nieuwe dict tot 1
stemming_resultaat[i[1]] = 0
for i in list(self.stemming.items()
): # plus 1 voor elke keer dat vote voorkomt
if i == self.burgermeester: # als burgermeester voeg 2 toe
stemming_resultaat[i[1]] += 2
else:
stemming_resultaat[i[1]] += 1
output = []
for i in list(stemming_resultaat.items()):
if i[1] == 1:
output.append("{} stem voor {} ".format(i[1], i[0]))
else:
output.append("{} stemmen voor {} ".format(i[1], i[0]))
output.sort()
await self.stemming_bericht.edit(
content=
"@here We gaan nu stemmen op de persoon die wordt vermoord\n\nStemming:\n{}"
.format("\n".join(output)))
if len(
self.stemming
) == 2: # Er is dus evenveel stemmen als de win condition
hoogste = (None, 0)
for i in list(stemming_resultaat.items()):
if i[1] > hoogste[1]:
hoogste = i #evalutionaire algoritme??
if list(stemming_resultaat.values()).count(
hoogste[1]
) > 1: # als stemming meer and 1 keer voor komt
await self.stemming_bericht.edit(
content=
"@here We gaan nu stemmen op de persoon die wordt vermoord\n\nStemming:\n{}\n\nHet staat momenteel gelijk"
.format("\n".join(output)))
await message.delete()
return
else: # de stemming is goed gegaan dan gaat dit:
if await self.win_check():
return
await message.delete()
await self.stemming_bericht.delete()
winning_player = next(
(player for player in self.player_lijst
if player.name == self.return_member(
mention=hoogste[0]).name))
await self.het_plein_channel.send(embed=discord.Embed(
description=
"{} is gekozen en wordt vermoord\n{} was {}".
format(hoogste[0], hoogste[0],
winning_player.rol_display_name),
colour=discord.Colour(value=2195054)))
await winning_player.die(self.dood_rol)
self.players_levend_list = [
i for i in self.player_lijst if i.levend
]
self.players_levend_list_member = [
i.member for i in self.player_lijst if i.levend
]
if self.ziener_levend == True:
self.gameloop_currentrol = "ziener"
await self.het_plein_channel.send(
"De ziener wordt wakker en bekijkt iemands persoonlijkheid"
)
self.ziener_vote = Vote(
message_text="Wie wil de ziener bekijken",
speler_lijst=self.players_levend_list,
channel=self.ziener_channel)
await self.ziener_vote.send_message()
else:
self.gameloop_currentrol = "weerwolfen"
await self.het_plein_channel.send(
"De weerwolfen worden wakker opzoek naar een midnight snack"
)
self.weerwolfen_vote = Vote(
message_text="Wie gaan julie opeten",
speler_lijst=[
speler for speler in self.player_lijst
if speler.rol_display_name != "Weerwolf"
and speler.levend == True
],
channel=self.weerwolfen_channel)
await self.weerwolfen_vote.send_message()
self.killed = []
else:
await message.delete()
# !join all
if self.bericht_text[0] == "!join" and len(self.bericht_text) == 1:
if self.join_message:
await self.join_message.delete()
self.join_message = await message.channel.send(
"**Join weerwolfen** {} \n{} wil een weerwolfen potje beginnen, click op de emoji om mee te doen"
.format(self.weerwolfen_spel_rol.mention,
message.author.mention))
await self.join_message.add_reaction("🐺")
if self.bericht_text[0] == "!join" and self.bericht_text[
1] == "all":
for i in self.server.members:
await i.add_roles(self.weerwolfen_spel_rol)
await message.channel.send("Done", delete_after=2)
return
# exit remove text channels
if self.bericht_text[0] == "!exit":
# if self.init == False:
# return
# self.init = False
for i in self.server.channels:
if i.category != None and i.category.name == "Weerwolfen":
await i.delete()
for i in self.server.categories:
if i.name == "Weerwolfen":
await i.delete()
delete_list = []
for i in self.server.roles:
if i.name[:4] == "spel" or i.name == "Dood":
delete_list.append(i)
for i in delete_list: # anders lukt het niet goed
await i.delete()
return
# purge
if self.bericht_text[0] == "!purge":
try:
if len(self.bericht_text
) == 1 or self.bericht_text[1] == 1:
hoeveel_messages = 2
else:
hoeveel_messages = int(self.bericht_text[1]) + 1
await message.channel.purge(limit=hoeveel_messages)
except ValueError:
await message.channel.send("Geen getal gegeven",
delete_after=7)
return
if self.bericht_text[0] == "!tes":
pass
def generate_random_vote() -> Vote:
return Vote(trustworthy=choice([True, False]))
