async def qp(self, ctx, number_of_tickets=1):
"""
Quickpick tickets, enter a number to choose how many you want!
"""
lottory_id = db.get_current_lottory()
user_balance = db.get_user_balance(ctx.author.id)
total_cost = ticket_cost * number_of_tickets
if user_balance < total_cost:
await ctx.send("That would cost {:,}, your balance is {:,}. Broke ass bitch".format(total_cost, user_balance))
return
else:
async with ctx.typing():
ticket_list = quickpick(number_of_tickets)
progressive_add = number_of_tickets * ticket_cost * .1
db.add_ticket_to_user(ticket_list, lottory_id, ctx.author.id)
new_balance = db.modify_user_balance(ctx.author.id, -1 * total_cost)
db.modify_lottory_jackpot_prog(lottory_id, progressive_add)
new_progressive = db.get_lottory_jackpot_prog(lottory_id)
ticket_obj_list = list(map(lambda x: Ticket(x), ticket_list)) #Convert list of tickets to Ticket objects
if len(ticket_list) <= 5:
output_line_list = []
for ticket in ticket_list:
output_line_list.append('Quickpick ticket {} purchased by {}, good luck!'.format(Ticket(ticket), ctx.author.name))
await ctx.send("\n".join(output_line_list))
if number_of_tickets > 500:
await ctx.author.send("You bought {} tickets. I'm not going to send you all of them.".format(number_of_tickets))
else:
for n in range(0, len(ticket_list), 50):
await ctx.author.send("Lottory {} Quickpick tickets {}".format(lottory_id, ticket_list[n:n+50]))
await ctx.send("{} spent {:,} on {:,} tickets, new balance is {:,}. The jackpot is now {:,}".format(ctx.author.name, total_cost, number_of_tickets, round(new_balance,2), payout_table[True][4]+new_progressive))
async def modify_prog(self, ctx, amount: int):
if ctx.author.id != 154415714411741185:
await ctx.send("You're not my real dad!")
return
lid = db.get_current_lottory()
new_prog = db.modify_lottory_jackpot_prog(lid, amount)
jackpot = new_prog + payout_table[True][4]
await ctx.send("Lottory {} jackpot is now {}".format(lid, jackpot))
async def status(self,ctx):
'''Display the current lottory status'''
lottory_id = db.get_current_lottory()
tickets = db.get_lottory_tickets(lottory_id)
num_tickets = len(tickets)
progressive = db.get_lottory_jackpot_prog(lottory_id)
jackpot = payout_table[True][4] + progressive
await ctx.send("Lottory {} is in progress, currently {:,} tickets sold, current jackpot is {:,}".format(lottory_id,num_tickets,jackpot))
async def tickets(self, ctx, lottory_id=None):
"""
DM all tickets for current lottory, or lottory id if given.
"""
lottory = db.get_current_lottory() if lottory_id is None else lottory_id
ticket_list = db.get_user_tickets(ctx.author.id,lottory)
await ctx.send('{} has {} tickets in the curret drawing.'.format(ctx.author, len(ticket_list)))
for n in range(0, len(ticket_list), 50):
await ctx.author.send('{}'.format(ticket_list[n:n+50]))
async def balance(self, ctx):
'''Shows your balance and number of tickets in current drawing'''
balance = db.get_user_balance(ctx.author.id)
lottory_id = db.get_current_lottory()
ticket_list = db.get_user_tickets(ctx.author.id, lottory_id)
await ctx.send(
"{} balance is {:,}. You have {} tickets in the next drawing".
format(ctx.author.name, round(balance, 2), len(ticket_list)))
async def info(self, ctx):
'''Displays the paytable'''
lid = db.get_current_lottory()
progressive = db.get_lottory_jackpot_prog(lid)
await ctx.send(
"4 Unordered Balls <1-23>, 1 MEGABALL <1-11> - Ticket cost {:,} \n Match 4+1 win {:,} + {:,} progressive!\nMatch 4 win {:,}\nMatch 3+1 win {:,}\nMatch 3 win {:,}\nMatch 2+1 win {:,}\nMatch 2+0 win {:,}\nMatch 1+1 win {:,}\nChance to win ANY prize 1:6"
.format(ticket_cost, payout_table[True][4], progressive,
payout_table[False][4], payout_table[True][3],
payout_table[False][3], payout_table[True][2],
payout_table[False][2], payout_table[True][1]))
async def lottory(self, ctx, confirm):
'''Advances to next lottory, this will abandon all tickets from previous if
it was not drawn first!'''
if ctx.author.id != 154415714411741185:
await ctx.send("You're not my real dad!")
return
if confirm != "confirm":
await ctx.send("Please confirm")
return
db.add_lottory(0)
lottory_id = db.get_current_lottory()
await ctx.send("Lottory {} has begun, purchase tickets now!".format(lottory_id))
async def buy_ticket(self, ctx, first: int, second: int, third: int,
fourth: int, mega: int):
"""
Purchase a lottory ticket, enter all 5 numbers seperated by spaces.
Valid tickets must have first 4 numbes between 1-23, and last number between 1-11.
Use !bt qp <number> to purchase a number of quickpick tickets. Good luck!
"""
lottory_id = db.get_current_lottory()
user_balance = db.get_user_balance(ctx.author.id)
ticket = [first, second, third, fourth, mega]
ticket_print = Ticket(ticket)
if user_balance < ticket_cost:
await ctx.send(
"That would cost {:,}, your balance is {:,}. Broke ass bitch".
format(ticket_cost, user_balance))
return
#Validate ticket entry
for number in ticket[:4]:
if number not in numbers:
await ctx.send(
"{} is not a valid ticket, first 4 numbers must be between {}-{}}"
.format(ticket, numbers[0], numbers[-1]))
return
if ticket[4] not in range(1, 12):
await ctx.send(
"{} is not a valid ticket, megaball must be between 1-11".
format(ticket))
return
for i in range(3):
if ticket[i] in ticket[:i]:
await ctx.send(
"{} is not a valid ticket, first four numbers must be unique"
.format(ticket_print))
return
if ticket[i] in ticket[i + 1:4]:
await ctx.send(
"{} is not a valid ticket, first four numbers must be unique"
.format(ticket_print))
return
progressive_add = ticket_cost * .1
db.add_ticket_to_user([ticket], lottory_id, ctx.author.id)
new_balance = db.modify_user_balance(ctx.author.id, -1 * ticket_cost)
db.modify_lottory_jackpot_prog(lottory_id, progressive_add)
new_progressive = db.get_lottory_jackpot_prog(
lottory_id) + payout_table[True][4]
await ctx.send(
"{} purchased ticket {}, your balance is now {:,}. The progressive jackpot is now {:,}."
.format(ctx.author.name, Ticket(ticket), new_balance,
new_progressive))
async def draw(self,ctx):
'''Start the next drawing'''
lottory_id = db.get_current_lottory()
progressive = db.get_lottory_jackpot_prog(lottory_id)
total_jackpot = progressive + payout_table[True][4]
ticket_list = db.get_lottory_tickets(lottory_id) #List of tuples (user_id, ticket_value)
if len(ticket_list) < 1: #Verify there is at least 1 ticket sold before allowing drawing
await ctx.send("There are no tickets sold for this drawing yet!")
return
db.add_lottory() #increment current when drawing starts
winning_numbers = quickpick()[0] #Choose winning numbers
balls = {0:'First', 1:'Second', 2:'Third', 3:'Fourth', 4:'MEGA'}
embed_dict = {'colour':discord.Colour(0x006400), 'author_name':"Drawing for lottory {}! Jackpot is currently {:,}".format(lottory_id,total_jackpot),
'fields': {}
}
lottory_message = await ctx.send(embed=build_embed(embed_dict))
async with ctx.typing():
winning_ticket_display = []
for ball_number, ball_name in balls.items():
await asyncio.sleep(3)
winning_ticket_display.append(str(winning_numbers[ball_number]))
embed_dict['fields'][1] = {'name': "{} Ball".format(ball_name), 'value': winning_numbers[ball_number], 'inline': True}
winning_numbers_value = "-".join(winning_ticket_display) if len(winning_ticket_display) < 5 else Ticket(winning_numbers)
embed_dict['fields'][2] = {'name': 'Winning Numbers' , 'value': winning_numbers_value, 'inline': True}
await lottory_message.edit(embed=build_embed(embed_dict))
num_tickets = len(ticket_list)
progressive_split = []
winner_dict = {}
loser_dict = {}
total_payout = 0
async with ctx.typing():
for ticket_tuple in ticket_list:
ticket_value = eval(ticket_tuple[0]) #ticket value stored as a string, convert back to list
user_id = ticket_tuple[1]
mega, match = parse_ticket(winning_numbers, ticket_value)
ticket_payout = determine_payout(mega, match)
if ticket_payout != 0:
winner_dict = add_ticket_to_dict(winner_dict, user_id, ticket_value, ticket_payout)
else:
loser_dict = add_ticket_to_dict(loser_dict, user_id, ticket_value, ticket_payout)
results = {}
async with ctx.typing():
for user_id, list_of_winning_tickets in winner_dict.items():
balance_modifier = 0
for ticket_tuple in list_of_winning_tickets:
ticket_value = Ticket(ticket_tuple[0])
ticket_payout = ticket_tuple[1]
if ticket_payout == payout_table[True][4]:
progressive_split.append([user_id, ticket_value])
else:
balance_modifier += ticket_payout
new_user_balance = db.modify_user_balance(user_id, balance_modifier)
results[user_id] = [balance_modifier, new_user_balance, list_of_winning_tickets]
total_payout += balance_modifier
jackpot_results = {}
if len(progressive_split) > 0:
jackpot_progressive_share = round(progressive / len(progressive_split), 2)
jackpot_payout = round(payout_table[True][4] + jackpot_progressive_share, 2)
for ticket_tuple in progressive_split:
user_id = ticket_tuple[0]
ticket_value = ticket_tuple[1]
total_payout += jackpot_payout
new_user_balance = db.modify_user_balance(user_id, jackpot_payout)
if user_id not in jackpot_results:
jackpot_results[user_id] = [jackpot_payout, new_user_balance, [ticket_value], jackpot_progressive_share]
else:
jackpot_results[user_id][0] += jackpot_payout
jackpot_results[user_id][1] = new_user_balance
jackpot_results[user_id][2].append(ticket_value)
jackpot_results[user_id][3] += jackpot_progressive_share
split_won = 'won' if len(jackpot_results) == 1 else 'split'
await ctx.send("------------JACKPOT WINNAR!!!!!!-------------")
for user_id, result in jackpot_results.items():
jackpot_payout = result[0]
new_user_balance = result[1]
ticket_values = result[2] if len(result[2]) <= 10 else len(result[2])
progressive_split = result[3]
user = await self.bot.get_user_info(user_id)
await ctx.send('{} {} the Jackpot! Payout {:,}, your share of the progressive is {:,}! with {} tickets!!'.format(user.name, split_won, round(jackpot_payout,2), round(progressive_split,2), ticket_values))
await user.send('You {} the Jackpot for lottory {} with ticket {}! {:,} has been deposited into your account. Your new balance is {}.'.format(split_won, lottory_id, ticket_value, round(jackpot_payout,2), new_user_balance))
for user_id, result in results.items():
jackpot_balance_modifier = jackpot_results[user_id][0] if user_id in jackpot_results else 0
balance_modifier = result[0] + jackpot_balance_modifier
new_user_balance = result[1]
winning_tickets = result[2]
user = await self.bot.get_user_info(user_id)
embed_dict['fields'][user_id] = {'name': user.name, 'value': "Won a total of {:,} on {:,} winning tickers!".format(balance_modifier, len(winning_tickets)), 'inline': False}
await user.send("Lottory {} Results: You won {:,}. Your new balance is {:,}.".format(lottory_id, balance_modifier, new_user_balance))
if len(winning_tickets) < 100:
for n in range(0, len(winning_tickets), 50):
await user.send("Your winnings tickets for Lottory {}: Winning Numbers:{} Your winners: {}".format(lottory_id, winning_numbers, winning_tickets[n:n+50]))
await lottory_message.edit(embed=build_embed(embed_dict))
income = ticket_cost * num_tickets
payout_ratio = 100 * (total_payout - income) / income
db.update_lottory_stats(lottory_id, income, total_payout)
embed_dict['author_name'] = "Lottory {} ended!".format(lottory_id)
embed_dict['fields'][0] = {"name": "{:,} tickets were sold for {:,}".format(num_tickets, income), 'value':"{:,} was paid out for a payout ratio of {}%".format(round(total_payout, 2), round(payout_ratio, 2))}
await lottory_message.edit(embed=build_embed(embed_dict))
if len(progressive_split) == 0:
lottory_id = db.get_current_lottory() #Add progressive to next lottory
db.modify_lottory_jackpot_prog(lottory_id, progressive)
else:
await ctx.send("Jackpot has been reseeded to {:,}".format(payout_table[True][4]))
