async def run(message:discord.Message):
# parse message
message_args = message.content.split(" ")
if(len(message_args) ==3):
enemy_row = await calculateRowFWG(message_args[0])
status = message_args[2].lower()
if(enemy_row != -1 and len(message.mentions) == 1 and (status == "win" or status == "lose")):
# check if discord id inside the spreadsheet if not then add it with first time set up
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
ws = sh.worksheet("Basic Data")
values_list = ws.col_values(DISCORD_ID_COLUMN, value_render_option='UNFORMATTED_VALUE')
discord_id = str(message.mentions[0].id)
if(discord_id in values_list):
row = values_list.index(discord_id)+1
else:
row = len(remove_values_from_list(values_list,""))
ws.update_cell(row, DISCORD_ID_COLUMN, discord_id)
ws.update_cell(row, DISCORD_MEMBER_NAME, message.mentions[0].name)
# update attacked by (ally)
attacked_by_info = ws.cell(row, ATTACKED_BY_COLUMN, value_render_option='UNFORMATTED_VALUE').value
ws.update_cell(row, ATTACKED_BY_COLUMN, "{}\n{} {} against you".format(attacked_by_info,message_args[0],status.capitalize()))
# update attacked (enemy)
ws = sh.worksheet("Enemy Data")
attacked_by_info = ws.cell(enemy_row, ENEMY_ATTACKED, value_render_option='UNFORMATTED_VALUE').value
ws.update_cell(enemy_row, ENEMY_ATTACKED, "{}\n{} against {}".format(attacked_by_info,status.capitalize(),message.mentions[0].name))
await message.add_reaction(getDefaultEmoji("white_check_mark"))
else:
await message.add_reaction(getDefaultEmoji("x"))
else:
await message.add_reaction(getDefaultEmoji("x"))
async def run(dbConfig, client, ctx, *args):
#acquired = lock.acquire(blocking=True, timeout=60)
acquired = lock.acquire(blocking=False)
if acquired:
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
else:
await ctx.message.add_reaction(getDefaultEmoji("x"))
return
try:
await engine(dbConfig,client,ctx,*args)
finally:
if acquired:
lock.release()
async def run(client, ctx:commands.context, *search):
""" resets the spreadsheet of everyone to 4 runs.
Arguments:
client {discord.client} -- discord bot object
ctx {commands.context} -- context of the message
"""
current_user = ctx.message.author
print("in")
if(current_user.guild.id == 708002106245775410):
has_access = False
print("correct server")
print(current_user.roles)
for temp_roles in current_user.roles:
if(temp_roles.id == 708005221586042881):
has_access = True
if(has_access):
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FR")
ws = sh.worksheet("Basic Data")
runs = ws.col_values(3, value_render_option='UNFORMATTED_VALUE')
# -1 b/c total runs
for index in range(0,len(runs)-1):
if(isinstance(runs[index], int)):
ws.update_cell(index+1, 3, 4)
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
async def run(dbConfig, client, ctx, *args):
author = str(ctx.message.author)
content = ctx.message.content
print("\nReceived message from '"+author+"' with content '"+content+"'")
if "img" in args:
gacha_mode = GachaModes.IMG
elif "gif" in args:
gacha_mode = GachaModes.GIF
else:
await ctx.message.add_reaction(getDefaultEmoji("x"))
user = User.get_user(dbConfig, author)
user.gacha_mode = gacha_mode.value
user.update_user(dbConfig,datetime.datetime.now(),content)
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
async def run(ctx, target, note):
curr_note = ""
for words in note:
curr_note = curr_note + words + " "
# get the row based on target
row = await calculateRowFWG(target)
# update note on the enemy
if (row != -1):
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
ws = sh.worksheet("Enemy Data")
cell_info = ws.cell(row,
NOTE_COLUMN,
value_render_option='UNFORMATTED_VALUE').value
ws.update_cell(row, NOTE_COLUMN, cell_info + "\n•" + curr_note)
if (row != -1):
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
else:
await ctx.message.add_reaction(getDefaultEmoji("x"))
async def run(message):
# header
errors = ""
current_message = message.content.lower()
row = await calculateRowFWG(current_message)
if(row != -1):
if(len(message.attachments) != 0):
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
ws = sh.worksheet("Enemy Data")
cell_info = ""
for attachment in message.attachments:
cell_info = cell_info + '=IMAGE("{}",4,192,384)'.format(attachment.url) + "\n"
# end of stages column after
ws.update_cell(row,TEAM_PIC_COLUMN,cell_info)
else:
errors = "no attachment found"
if(errors == "" and row != -1):
await message.add_reaction(getDefaultEmoji("white_check_mark"))
else:
await message.add_reaction(getDefaultEmoji("x"))
async def run(ctx):
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
#ENEMY DATA WIPE
ws = sh.worksheet("Enemy Data")
wipeRow(ws, "B2", "B31", "", 30)
wipeRow(ws, "C2", "C31", "", 30)
wipeRow(ws, "D2", "D31", "", 30)
wipeRow(ws, "E2", "E31", "", 30)
wipeRow(ws, "F2", "F31", "", 30)
wipeRow(ws, "G2", "G31", "", 30)
ws = sh.worksheet("Basic Data")
wipeRow(ws, "C2", "C31", 3, 30)
wipeRow(ws, "D2", "D31", "", 30)
wipeRow(ws, "E2", "E31", "", 30)
wipeRow(ws, "G2", "G31", "", 30)
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
async def run(ctx,ally:discord.Member,enemy):
# check if valid enemy
enemy_row = await calculateRowFWG(enemy)
if(enemy_row != -1):
# check if discord id inside the spreadsheet if not then add it with first time set up
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
ws = sh.worksheet("Basic Data")
values_list = ws.col_values(DISCORD_ID_COLUMN, value_render_option='UNFORMATTED_VALUE')
print(values_list)
discord_id = str(ally.id)
if(discord_id in values_list):
row = values_list.index(discord_id)+1
else:
row = len(remove_values_from_list(values_list,""))
ws.update_cell(row, DISCORD_ID_COLUMN, discord_id)
ws.update_cell(row, DISCORD_MEMBER_NAME, ally.name)
# get all current suggestions and add on to it
curr_suggestions = ws.cell(row, ATTACK_SUGGESTION_COLUMN, value_render_option='UNFORMATTED_VALUE').value
ws.update_cell(row, ATTACK_SUGGESTION_COLUMN, "{}\n{}".format(curr_suggestions,enemy))
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
async def pageUnitsHandler(client, ctx, page_list, db, total_results, search):
"""This handles the message scrolling of the character search and all the other
page logic for multiple results
Arguments:
client {discord.client} -- the discord bot object
ctx {discord.context} -- command message context
page_list {list of list} -- list of pages, Pages are lists with adventurers. Adventurers are tuples with (id,title,adventurername)
db {DBController.DBController} -- Database connector object
total_results {int} -- total number of results from the query
search {string} -- the search query
"""
# set up
current_page = 0
temp_embed = discord.Embed()
temp_embed.description = "React on the numbers to display the corresponding units!"
temp_embed.color = Status.OK.value
temp_embed.title = "{} results for {}".format(str(total_results), search)
if (len(page_list) == 0):
page_list.append(
[["", "No relevant characters to display", "End of List"]])
temp_embed.set_footer(text="Page {} of {}".format(current_page +
1, len(page_list)))
emoji1 = '\u2b05'
emoji2 = '\u27a1'
emoji_list = [
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
"nine"
]
emoji_react = getDefaultEmoji(emoji_list)
def clearSetField(temp_embed: discord.Embed, field_list):
temp_embed.clear_fields()
count = 0
for skills in field_list:
temp_embed.add_field(value="[{}] {}".format(skills[1], skills[2]),
name=emoji_react[count],
inline=False)
count = count + 1
return temp_embed
temp_embed = clearSetField(temp_embed, field_list=page_list[current_page])
temp_embed.set_image(url="attachment://temp.png")
icons = get_units_image(page_list)
msg = await ctx.send(embed=temp_embed,
file=discord.File(icons, filename="temp.png"))
await msg.add_reaction(emoji1)
await msg.add_reaction(emoji2)
for emoji in emoji_react:
await msg.add_reaction(emoji)
def check(payload):
return (
(str(payload.emoji) in emoji_react) or
(str(payload.emoji) == emoji1) or (str(payload.emoji) == emoji2)
) and payload.user_id != client.user.id and payload.message_id == msg.id
def wait_for_reaction(event_name):
return client.wait_for(event_name, check=check)
while True:
pending_tasks = [
wait_for_reaction("raw_reaction_add"),
wait_for_reaction("raw_reaction_remove")
]
done_tasks, pending_tasks = await asyncio.wait(
pending_tasks, timeout=60.0, return_when=asyncio.FIRST_COMPLETED)
timeout = len(done_tasks) == 0
if not timeout:
task = done_tasks.pop()
reaction = await task
for remaining in itertools.chain(done_tasks, pending_tasks):
remaining.cancel()
if timeout:
temp_embed.color = Status.KO.value
await msg.edit(embed=temp_embed)
break
# left
if str(reaction.emoji) == emoji1:
if (current_page > 0):
current_page = current_page - 1
else:
current_page = len(page_list) - 1
temp_embed.set_footer(
text="Page {} of {}".format(current_page + 1, len(page_list)))
temp_embed = clearSetField(temp_embed,
field_list=page_list[current_page])
await msg.edit(embed=temp_embed)
# right
if str(reaction.emoji) == emoji2:
if (current_page + 1 < len(page_list)):
current_page = current_page + 1
else:
current_page = 0
temp_embed.set_footer(
text="Page {} of {}".format(current_page + 1, len(page_list)))
temp_embed = clearSetField(temp_embed,
field_list=page_list[current_page])
await msg.edit(embed=temp_embed)
if ((str(reaction.emoji) in emoji_react)):
print("test")
if (len(page_list[current_page]) > emoji_react.index(
str(reaction.emoji))):
await msg.delete()
await singleAdventurer(
client, ctx, db, page_list[current_page][emoji_react.index(
str(reaction.emoji))])
async def run(client, ctx: commands.context, *search):
""" record your mock run
Arguments:
client {discord.client} -- discord bot object
ctx {commands.context} -- context of the message
search {string} -- contains arguments on the info of your run
arguments for search:
<day> : 1-7
<diff>: 20,40,60,80,100,110
<stage>: 1,2,3
<damage>: >=0 (you can write 13m or 13kk instead of 13000000)
Search template:
diff<diff> day<day> stage<stage> damage<damage>
"""
current_user = ctx.message.author
print("in")
if (current_user.guild.id == 708002106245775410):
has_access = False
print("correct server")
print(current_user.roles)
for temp_roles in current_user.roles:
if (temp_roles.id == 708008774140690473
or temp_roles.id == 708005221586042881):
has_access = True
if (has_access):
errors = ""
score_list = []
# number converting and understanding
for arguments in search:
if ("diff" in arguments or "difficulty" in arguments):
difficulty_list = [20, 40, 60, 80, 100, 110]
difficulty = int(
arguments.replace("difficulty",
"").replace("diff", "").strip())
if (not difficulty in difficulty_list):
errors = "invalid difficulty please have a difficulty that is: 20,40,60,80,100 or 110"
elif ("st" in arguments or "stage" in arguments):
try:
stage = int(
arguments.replace("stage", "").replace("st",
"").strip())
except:
errors = "no decimals in stage"
if (stage > 3 or stage < 1):
errors = "Incorrect stage value please have a day between 1-3"
elif ("dmg" in arguments or "damage" in arguments):
score = arguments.replace("damage",
"").replace("dmg", "").replace(
",", "").strip()
temp_scores = score.split("$")
for items in temp_scores:
temp_item = items.lower()
if ("m" in items):
temp_item = temp_item.replace("m", "")
temp_item = float(temp_item) * 1000000
elif ("kk" in temp_item):
temp_item = temp_item.replace("kk", "")
temp_item = float(temp_item) * 1000000
elif ("k" in temp_item):
temp_item = temp_item.replace("k", "")
temp_item = float(temp_item) * 1000
try:
temp_item = int(temp_item)
score_list.append(temp_item)
except:
errors = "please have a numerical damage or have 'm', 'kk' or 'k' in the damage"
if (temp_item < 0):
errors = "Negative damage"
elif ("d" in arguments or "day" in arguments):
print(arguments)
try:
day = int(
arguments.replace("day", "").replace("d",
"").strip())
except:
errors = "no decimals in days"
if (day > 7 or day < 1):
errors = "Incorrect day value please have a day between 1-7"
if (errors != ""):
temp_embed = discord.Embed()
temp_embed.color = 16203840
temp_embed.title = "Argument Error"
temp_embed.description = errors
await ctx.send(embed=temp_embed)
else:
try:
for scores in score_list:
await recordMockRun(ctx, current_user, day, stage,
difficulty, scores)
await ctx.message.add_reaction(
getDefaultEmoji("white_check_mark"))
except:
await ctx.message.add_reaction(getDefaultEmoji("x"))
temp_embed = discord.Embed()
temp_embed.color = 16203840
temp_embed.title = "Argument Error"
temp_embed.description = "missing an argument"
await ctx.send(embed=temp_embed)
async def run(client,ctx,target,medals:int):
enemy_row = await calculateRowFWG(target)
if(enemy_row != -1):
# check if discord id inside the spreadsheet if not then add it with first time set up
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FWG")
ws = sh.worksheet("Basic Data")
values_list = ws.col_values(DISCORD_ID_COLUMN, value_render_option='UNFORMATTED_VALUE')
discord_id = str(ctx.message.author.id)
msg = ctx.message
print(values_list)
print(discord_id)
if(discord_id in values_list):
row = values_list.index(discord_id)+1
else:
row = len(remove_values_from_list(values_list,""))
ws.update_cell(row, DISCORD_ID_COLUMN, discord_id)
ws.update_cell(row, DISCORD_MEMBER_NAME, ctx.message.author.name)
# add one to medals (default whenever you run 1)
# subtract run if equal to 0 then warn user
# check if there are any runs left
runs = ws.cell(row, RUNS_COLUMN, value_render_option='UNFORMATTED_VALUE').value
is_medal = True
# if its 0 give error msg
if (str(runs) == "0"):
await ctx.send("Unable to record runs because you have 0 left")
await ctx.message.add_reaction(getDefaultEmoji("x"))
else:
ws = sh.worksheet("Enemy Data")
# ask with reaction to see if its l or g or none (FIRST TIME ONLY)
role = ws.cell(enemy_row, LIEUT_GEN_COLUMN, value_render_option='UNFORMATTED_VALUE').value
role_column = ws.col_values(LIEUT_GEN_COLUMN, value_render_option='UNFORMATTED_VALUE')
lieutenant_count = role_column.count("Lieutenant")
general_count = role_column.count("General")
print(general_count)
print(lieutenant_count)
if((role == "?" or role =="" ) and (general_count < 1 or lieutenant_count < 3)):
print("in")
x_emoji = getDefaultEmoji("regional_indicator_m")
lieutenant_emoji = getDefaultEmoji("regional_indicator_l")
general_emoji = getDefaultEmoji("regional_indicator_g")
await msg.add_reaction(x_emoji)
if(lieutenant_count < 3):
await msg.add_reaction(lieutenant_emoji)
if(general_count < 1):
await msg.add_reaction(general_emoji)
def check(reaction, user):
return (str(reaction.emoji) == x_emoji
or str(reaction.emoji) == lieutenant_emoji
or str(reaction.emoji) == general_emoji) and user !=client.user and reaction.message.id == msg.id
def wait_for_reaction(event_name):
return client.wait_for(event_name,check=check)
pending_tasks = [wait_for_reaction("reaction_add"), wait_for_reaction("reaction_remove")]
done_tasks, pending_tasks = await asyncio.wait(pending_tasks, timeout=10.0, return_when=asyncio.FIRST_COMPLETED)
timeout = len(done_tasks) == 0
if not timeout:
task = done_tasks.pop()
reaction, user = await task
if timeout:
is_medal=False
await msg.add_reaction(getDefaultEmoji("x"))
for remaining in itertools.chain(done_tasks, pending_tasks):
remaining.cancel()
if str(reaction.emoji) == x_emoji:
if(medals <= 3 and medals >=0):
ws.update_cell(enemy_row, LIEUT_GEN_COLUMN, "Member")
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, 6-medals)
else:
is_medal=False
if str(reaction.emoji) == lieutenant_emoji:
if(medals <=5 and medals >=0):
ws.update_cell(enemy_row, LIEUT_GEN_COLUMN, "Lieutenant")
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, 45-medals)
else:
is_medal=False
if str(reaction.emoji) == general_emoji:
if(medals <=6 and medals >=0):
ws.update_cell(enemy_row, LIEUT_GEN_COLUMN, "General")
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, 66-medals)
else:
is_medal=False
# 100% Member
elif(role == "?" or role == ""):
ws.update_cell(enemy_row, LIEUT_GEN_COLUMN, "Member")
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, 6-medals)
else:
# medals checking
if(role == "General"):
if(not(medals <=6 and medals >=0)):
is_medal=False
elif(role == "Lieutenant"):
if(not(medals <=5 and medals >=0)):
is_medal=False
#member
else:
if(not(medals <=3 and medals >=0)):
is_medal=False
if(is_medal):
enemy_medals = ws.cell(enemy_row, ENEMY_MEDALS_LEFT, value_render_option='UNFORMATTED_VALUE').value
if(enemy_medals - medals < 0 ):
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, 0)
else:
ws.update_cell(enemy_row, ENEMY_MEDALS_LEFT, enemy_medals-medals)
if(is_medal):
# add to attack by enemy data
# check if win or lose (lose == 0)
ws = sh.worksheet("Enemy Data")
attacked_by_info = ws.cell(enemy_row, ENEMY_ATTACKED_BY, value_render_option='UNFORMATTED_VALUE').value
if(medals == 0):
ws.update_cell(enemy_row, ENEMY_ATTACKED_BY, "{}\nWin against {}".format(attacked_by_info,ctx.message.author.name))
else:
ws.update_cell(enemy_row, ENEMY_ATTACKED_BY, "{}\nLose against {}".format(attacked_by_info,ctx.message.author.name))
# do the runs and other record now that everything is verified
ws = sh.worksheet("Basic Data")
# o/w if its empty then make it 3
if(not str(runs).strip()):
runs = 2
ws.update_cell(row, RUNS_COLUMN, runs)
# else if its not empty or 0 then subtract 1
else:
runs = runs -1
ws.update_cell(row, RUNS_COLUMN, runs)
# add to attack basic data
attacked_info = ws.cell(row, ATTACKED_COLUMN, value_render_option='UNFORMATTED_VALUE').value
if(medals == 0):
ws.update_cell(row, ATTACKED_COLUMN, "{}\nLose against {}".format(attacked_info,target))
else:
ws.update_cell(row, ATTACKED_COLUMN, "{}\nWin {} Medals against {}".format(attacked_info,medals,target))
# add to medals gained total
curr_medals = ws.cell(row, MEDAL_TOTAL_COLUMN, value_render_option='UNFORMATTED_VALUE').value
ws.update_cell(row, MEDAL_TOTAL_COLUMN, curr_medals + medals+1)
await msg.add_reaction(getDefaultEmoji("white_check_mark"))
else:
await msg.add_reaction(getDefaultEmoji("x"))
async def recordRealRun(ctx, user, day, stage, difficulty, score: int):
""" the logic and recording of the spreadsheet
Arguments:
ctx {discord.context} -- discord message context object
user {discord.user} -- the user that has sent the message
day {int} -- the day of the run: 1,2,3,4,5,6,7
stage {int} -- the stage # :1,2,3
difficulty {int} -- difficulty of the FR stage : 20,40,60,80,100,110
score {int} -- the score of the run
"""
gc = gspread.service_account(filename="./gspread.json")
sh = gc.open("Imanity FR")
# update the DB first
ws = sh.worksheet("Database")
# headers
# find the discord id. if it doesnt exist create one on the very bottom
discord_ids = ws.col_values(1, value_render_option='UNFORMATTED_VALUE')
print(discord_ids)
# check if user exists. if not then create a new row
if (str(user.id) in discord_ids):
row = discord_ids.index(str(user.id)) + 1
else:
row = len(remove_values_from_list(discord_ids, "")) * 3
ws.update_cell(row, 1, str(user.id))
ws.update_cell(row, 2, user.name)
# record the actual run
current_row = row + stage - 1
scores = remove_values_from_list(
ws.row_values(current_row, value_render_option='UNFORMATTED_VALUE'),
"")
print(scores)
column = len(scores) + 1
if (stage != 1):
column = column + 2
print("{} {}".format(current_row, column))
ws.update_cell(current_row, column, score)
# green, blue, pink, orange, purple, yellow
difficulty_color = {
"20": {
"red": 0.0,
"green": 0.5,
"blue": 0.0
},
"40": {
"red": 0.1,
"green": 0.5,
"blue": 0.9
},
"60": {
"red": 0.3,
"green": 0.1,
"blue": 0.6
},
"80": {
"red": 0.9,
"green": 0.5,
"blue": 0.1
},
"100": {
"red": 0.592,
"green": 0.333,
"blue": 0.705
},
"110": {
"red": 0.58,
"green": 0.2,
"blue": 0.2
}
}
temp_dict = {"textFormat": {}}
temp_dict.get("textFormat")["foregroundColor"] = difficulty_color.get(
str(difficulty))
temp_add = ws.cell(current_row, column).address
ws.format(str(temp_add), temp_dict)
ws = sh.worksheet("Basic Data")
# update basic data sheet
discord_ids = ws.col_values(1)
print(discord_ids)
# find the discord id. if it doesnt exist create one on the very bottom
# check if user exists. if not then create a new row
if (str(user.id) in discord_ids):
row = discord_ids.index(str(user.id)) + 1
else:
row = len(remove_values_from_list(discord_ids, "")) + 3
ws.update_cell(row, 1, str(user.id))
ws.update_cell(row, 2, user.name)
#print(ws.cell(row, 1).address)
#update most recent
column = stage * 3
# recent score
ws.update_cell(row, column + 3, score)
# attachments
if (len(ctx.message.attachments) != 0):
cell_info = ""
for attachment in ctx.message.attachments:
cell_info = cell_info + '=IMAGE("{}")'.format(
attachment.url) + "\n"
# end of stages column after
ws.update_cell(row, 9 + 3 + stage, cell_info)
# check if there are any runs left
runs = ws.cell(row, 3, value_render_option='UNFORMATTED_VALUE').value
print(runs)
# if its 0 give error msg
if (str(runs) == "0"):
await ctx.send(
"Unable to record real run because you ran out of runs(treated as mock run). Runs left of today: {}"
.format(runs))
else:
# o/w if its empty then make it 3
if (not str(runs).strip()):
runs = 3
ws.update_cell(row, 3, runs)
# else if its not empty or 0 then subtract 1
else:
runs = runs - 1
ws.update_cell(row, 3, runs)
# # update daily score sheet
# ws = sh.worksheet("Daily Score")
# # find the discord id. if it doesnt exist create one on the very bottom
# discord_ids = ws.col_values(1,value_render_option='UNFORMATTED_VALUE')
# if(str(user.id) in discord_ids):
# row = discord_ids.index(str(user.id))+1
# else:
# row = len(remove_values_from_list(discord_ids,""))+2
# ws.update_cell(row, 1, str(user.id))
# ws.update_cell(row, 2, user.name)
# # add score for that day (score day x)
# column = day+2
# current_date_score = ws.cell(row, column, value_render_option='UNFORMATTED_VALUE').value
# if(str(current_date_score).strip() != ""):
# #print("CURRENT DATE SCORE: " + str(current_date_score))
# ws.update_cell(row, column, int(current_date_score)+score)
# else:
# ws.update_cell(row, column, score)
await ctx.message.add_reaction(getDefaultEmoji("white_check_mark"))
async def pageUnitsHandler(client, ctx, page_list, db, total_results, search):
"""This handles the message scrolling of the character search and all the other
page logic for multiple results
Arguments:
client {discord.client} -- the discord bot object
ctx {discord.context} -- command message context
page_list {list of list} -- list of pages, Pages are lists with adventurers. Adventurers are tuples with (id,title,adventurername)
db {DBController.DBController} -- Database connector object
total_results {int} -- total number of results from the query
search {string} -- the search query
"""
# set up
current_page = 0
temp_embed = discord.Embed()
temp_embed.description = "React on the numbers to display the corresponding units!"
temp_embed.color = Status.OK.value
temp_embed.title = "{} results for {}".format(str(total_results), search)
if (len(page_list) == 0):
page_list.append(
[["", "No relevant characters to display", "End of List"]])
temp_embed.set_footer(text="Page {} of {}".format(current_page +
1, len(page_list)))
emoji1 = '\u2b05'
emoji2 = '\u27a1'
emoji_list = [
"one", "two", "three", "four", "five", "six", "seven", "eight", "nine"
]
emoji_react = getDefaultEmoji(emoji_list)
def clearSetField(temp_embed: discord.Embed, field_list):
temp_embed.clear_fields()
count = 0
for skills in field_list:
temp_embed.add_field(value="[{}] {}".format(skills[1], skills[2]),
name=emoji_react[count],
inline=False)
count = count + 1
return temp_embed
temp_embed = clearSetField(temp_embed, field_list=page_list[current_page])
msg = await ctx.send(embed=temp_embed)
await msg.add_reaction(emoji1)
await msg.add_reaction(emoji2)
for emoji in emoji_react:
await msg.add_reaction(emoji)
def check(reaction, user):
return ((str(reaction.emoji) in emoji_react) or
(str(reaction.emoji) == emoji1) or
(str(reaction.emoji) == emoji2)
) and user != client.user and reaction.message.id == msg.id
while True:
try:
reaction, user = await client.wait_for('reaction_add',
timeout=60.0,
check=check)
except asyncio.TimeoutError:
temp_embed.color = Status.KO.value
await msg.edit(embed=temp_embed)
break
else:
# left
if str(reaction.emoji) == emoji1:
if (current_page > 0):
current_page = current_page - 1
else:
current_page = len(page_list) - 1
temp_embed.set_footer(
text="Page {} of {}".format(current_page +
1, len(page_list)))
temp_embed = clearSetField(temp_embed,
field_list=page_list[current_page])
await msg.edit(embed=temp_embed)
# right
if str(reaction.emoji) == emoji2:
if (current_page + 1 < len(page_list)):
current_page = current_page + 1
else:
current_page = 0
temp_embed.set_footer(
text="Page {} of {}".format(current_page +
1, len(page_list)))
temp_embed = clearSetField(temp_embed,
field_list=page_list[current_page])
await msg.edit(embed=temp_embed)
if ((str(reaction.emoji) in emoji_react)):
if (len(page_list[current_page]) > emoji_react.index(
reaction.emoji)):
await msg.delete()
await singleAdventurer(
client, ctx, db,
page_list[current_page][emoji_react.index(
reaction.emoji)])
async def pageRBHandler(client, ctx, logs, total_damage, total_score,
unit_list, ast_list):
"""This handles the logic of the page handling for the single result adventurer
Arguments:
client {discord.client} -- the discord bot object
ctx {discord.context} -- command message context
pages {list of discord.embeds} -- adventurer stats/skills page
"""
current_page = 0
#temp_embed.set_footer(text="Page {} of {}".format(current_page+1,len(pages)))
page_list = []
# first page
first_page = discord.Embed()
page_list.append(first_page)
first_page.color = Status.OK.value
first_page.title = "Summary of Record Buster"
# all the advs being used
first_page.add_field(name="Adventurers",
value="{}, {}, {}, {}, {}, {}".format(
unit_list[0].name, unit_list[1].name,
unit_list[2].name, unit_list[3].name,
unit_list[4].name, unit_list[5].name),
inline=False)
# all the assists being used
first_page.add_field(name="Assists",
value="{}, {}, {}, {}, {}, {}".format(
ast_list[0].name, ast_list[1].name,
ast_list[2].name, ast_list[3].name,
ast_list[4].name, ast_list[5].name),
inline=False)
# damage per adv
#current_damage
for adv in unit_list:
first_page.add_field(name="{} total damage".format(adv.name),
value="{:,}".format(int(adv.current_damage)),
inline=False)
# total damage
first_page.add_field(name="Total Damage",
value="{:,}".format(int(total_damage)),
inline=False)
# total score
first_page.add_field(name="Total Score",
value="{:,}".format(int(total_score)),
inline=False)
toggle_log_list = {"attack": True, "counters": False, "info": False}
# enemy, unit{0-3}, turn
# turn_logs = {"sa":[], "combat_skills":[], "counters":[], "sacs":[]}
#### set up pages ####
# title
# description
# color
# footer
# fields.append
# page_list[current_page].color = Status.OK.value
""" # page_list[current_page].color = Status.OK.value
logs_per_page = 1
logs_per_page_counter=1
field_list_temp=[]
temp_value = ""
for turn_logs in range(0,len(logs)):
#temp_value+="Turn {}\n".format(turn_logs+1)
temp_value+="{}\n{}\n".format("**RB Boss**", logs[turn_logs].get("enemy"))
# stats
for active_adv_count in range(0, 4):
temp_value+="{}\n".format(logs[turn_logs].get("unit{}".format(active_adv_count)))
field_list_temp.append(("Turn {}\n".format(turn_logs+1),temp_value))
if(logs_per_page_counter == logs_per_page or turn_logs ==len(logs)-1):
temp_embed = discord.Embed()
temp_embed.color = Status.OK.value
page_list.append(temp_embed)
temp_embed.title = "Buffs/Debuffs Check for Turn {}".format(turn_logs+1)
temp_embed.description="react to change pages\n"+temp_value
logs_per_page_counter=1
field_list_temp=[]
temp_value=""
else:
logs_per_page_counter+=1 """
emoji1 = '\u2b05'
emoji2 = '\u27a1'
rewind = '\u23ea'
forward = '\u23e9'
counters_toggle = getDefaultEmoji("shield")
attacks_toggle = getDefaultEmoji("crossed_swords")
info_toggle = getDefaultEmoji("information_source")
# whenever toggles
async def updateStats(page_list):
page_list = page_list[:1]
logs_per_page = 1
logs_per_page_counter = 1
field_list_temp = []
for turn_logs in range(0, len(logs)):
# attacks
if (toggle_log_list.get("attack") == True):
temp_value = ""
# sa
for sa in logs[turn_logs].get("sa"):
temp_value += "{}\n".format(sa)
# combatskills
for c_skill in logs[turn_logs].get("combat_skills"):
temp_value += "{}\n".format(c_skill)
if (temp_value != ""):
field_list_temp.append(("**Skills**", temp_value))
# counters
if (toggle_log_list.get("counters") == True):
temp_value = ""
for counter_skill in logs[turn_logs].get("counters"):
temp_value += "{}\n".format(counter_skill)
if (temp_value != ""):
field_list_temp.append(("**Counters**", temp_value))
# boost check
if (toggle_log_list.get("info") == True):
#temp_value+="Turn {}\n".format(turn_logs+1)
temp_value = ""
if (len(logs[turn_logs].get("enemy")) != 0):
field_list_temp.append(
("**RB Boss**", logs[turn_logs].get("enemy")))
# stats
for active_adv_count in range(0, 4):
#temp_value+="{}\n".format(logs[turn_logs].get("unit{}".format(active_adv_count)))
if (len(logs[turn_logs].get(
"unit{}".format(active_adv_count))) != 0):
field_list_temp.append(
("\U0000200e", logs[turn_logs].get(
"unit{}".format(active_adv_count))))
#field_list_temp.append(("**Info**",temp_value))
# sacs
temp_value = ""
for sacs in logs[turn_logs].get("sacs"):
temp_value += "{}\n".format(sacs)
if (temp_value != ""):
field_list_temp.append(("**Sacs**", temp_value))
if (logs_per_page_counter == logs_per_page
or turn_logs == len(logs) - 1):
temp_embed = discord.Embed()
temp_embed.color = Status.OK.value
page_list.append(temp_embed)
temp_embed.title = "Damage for Turn {}".format(turn_logs + 1)
temp_embed.description = "react to change pages"
for fields in field_list_temp:
temp_embed.add_field(name=fields[0],
value=fields[1],
inline=False)
logs_per_page_counter = 1
field_list_temp = []
else:
logs_per_page_counter += 1
#page_list[current_page].set_footer(text="Page {} of {}".format(current_page+1,len(page_list)))
return page_list
page_list = await updateStats(page_list)
# set footer for first page
page_list[
current_page].description = "react {} or {} to change pages\n{} to toggle sa/combat skills\n{} to toggle counters\n{}\
to toggle buffs/debuffs".format(emoji1, emoji2, attacks_toggle,
counters_toggle, info_toggle)
page_list[current_page].set_footer(
text="Page {} of {}".format(current_page + 1, len(page_list)))
msg = await ctx.send(embed=page_list[current_page])
await msg.add_reaction(rewind)
await msg.add_reaction(emoji1)
await msg.add_reaction(emoji2)
await msg.add_reaction(forward)
await msg.add_reaction(counters_toggle)
await msg.add_reaction(attacks_toggle)
await msg.add_reaction(info_toggle)
# set_field_at(index, *, name, value, inline=True)
def check(payload):
return (
str(payload.emoji) == emoji2 or str(payload.emoji) == emoji1
or str(payload.emoji) == rewind or str(payload.emoji) == forward
or str(payload.emoji) == counters_toggle or str(payload.emoji)
== attacks_toggle or str(payload.emoji) == info_toggle
) and payload.user_id != client.user.id and payload.message_id == msg.id
def wait_for_reaction(event_name):
return client.wait_for(event_name, check=check)
while True:
pending_tasks = [
wait_for_reaction("raw_reaction_add"),
wait_for_reaction("raw_reaction_remove")
]
done_tasks, pending_tasks = await asyncio.wait(
pending_tasks, timeout=60.0, return_when=asyncio.FIRST_COMPLETED)
timeout = len(done_tasks) == 0
if not timeout:
task = done_tasks.pop()
reaction = await task
for remaining in itertools.chain(done_tasks, pending_tasks):
remaining.cancel()
if timeout:
page_list[current_page].color = Status.KO.value
await msg.edit(embed=page_list[current_page])
break
# left
if str(reaction.emoji) == emoji1:
if (current_page > 0):
current_page = current_page - 1
else:
current_page = len(page_list) - 1
# right
if str(reaction.emoji) == emoji2:
if (current_page + 1 < len(page_list)):
current_page = current_page + 1
else:
current_page = 0
if str(reaction.emoji) == rewind:
current_page = 0
if str(reaction.emoji) == forward:
current_page = len(page_list) - 1
#toggle switch
if str(reaction.emoji) == attacks_toggle:
toggle_log_list["attack"] = not toggle_log_list.get("attack")
page_list = await updateStats(page_list)
if str(reaction.emoji) == counters_toggle:
toggle_log_list["counters"] = not toggle_log_list.get("counters")
page_list = await updateStats(page_list)
if str(reaction.emoji) == info_toggle:
toggle_log_list["info"] = not toggle_log_list.get("info")
page_list = await updateStats(page_list)
page_list[current_page].set_footer(
text="Page {} of {}".format(current_page + 1, len(page_list)))
page_list[
current_page].description = "react {} or {} to change pages\n{} to toggle sa/combat skills\n{} to toggle counters\n{}\
to toggle buffs/debuffs".format(emoji1, emoji2, attacks_toggle,
counters_toggle, info_toggle)
await msg.edit(embed=page_list[current_page])
