First Commit
This commit is contained in:
Executable
+509
@@ -0,0 +1,509 @@
|
||||
import discord
|
||||
from discord.ext import commands, tasks
|
||||
from utils.sql_commands import DatabaseManager
|
||||
from utils.bank_functions import bank_data, update_money
|
||||
from random import choice
|
||||
from datetime import datetime, timedelta
|
||||
import logging
|
||||
|
||||
TICKET_TYPES = {
|
||||
"standard": {"price": 500, "weight": 1},
|
||||
"premium": {"price": 2000, "weight": 5},
|
||||
}
|
||||
LOTTERY_INTERVAL_HOURS = 24 # Draw every 24 hours
|
||||
MAX_TICKETS_PER_USER = 10
|
||||
ROLLOVER_BONUS = 500
|
||||
|
||||
|
||||
class Lottery(commands.Cog):
|
||||
def __init__(self, client):
|
||||
self.client = client
|
||||
self.db = DatabaseManager()
|
||||
self.lottery_draw.start()
|
||||
|
||||
def cog_unload(self):
|
||||
self.lottery_draw.cancel()
|
||||
|
||||
def get_jackpot(self) -> int:
|
||||
try:
|
||||
result = self.db.fetch_one("SELECT jackpot FROM lottery_state WHERE id = 1")
|
||||
return int(result["jackpot"]) if result else 0
|
||||
except Exception as e:
|
||||
logging.error(f"Error fetching jackpot: {e}")
|
||||
return 0
|
||||
|
||||
def set_jackpot(self, amount: int) -> None:
|
||||
try:
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_state SET jackpot = %s WHERE id = 1", (amount,)
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error setting jackpot: {e}")
|
||||
|
||||
def add_to_jackpot(self, amount: int) -> None:
|
||||
try:
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_state SET jackpot = jackpot + %s WHERE id = 1",
|
||||
(amount,),
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error adding to jackpot: {e}")
|
||||
|
||||
def get_last_draw_time(self) -> datetime:
|
||||
try:
|
||||
result = self.db.fetch_one(
|
||||
"SELECT last_draw FROM lottery_draw_time WHERE id = 1"
|
||||
)
|
||||
last_draw = result["last_draw"] if result and result["last_draw"] else None
|
||||
if last_draw is None:
|
||||
# Set to now if missing and update DB
|
||||
now = datetime.utcnow()
|
||||
self.set_last_draw_time(now)
|
||||
return now
|
||||
if isinstance(last_draw, str):
|
||||
try:
|
||||
last_draw = datetime.fromisoformat(last_draw)
|
||||
except Exception:
|
||||
last_draw = datetime.strptime(last_draw, "%Y-%m-%d %H:%M:%S")
|
||||
return last_draw
|
||||
except Exception as e:
|
||||
logging.error(f"Error fetching last draw time: {e}")
|
||||
now = datetime.utcnow()
|
||||
self.set_last_draw_time(now)
|
||||
return now
|
||||
|
||||
def set_last_draw_time(self, draw_time: datetime) -> None:
|
||||
try:
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_draw_time SET last_draw = %s WHERE id = 1", (draw_time,)
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error setting last draw time: {e}")
|
||||
|
||||
def notify_lottery_result(self, user_id: int):
|
||||
try:
|
||||
result = self.db.fetch_one(
|
||||
"SELECT * FROM lottery_results WHERE WINNER_ID = %s AND CLAIMED = 0 ORDER BY DRAW_TIME DESC LIMIT 1",
|
||||
(user_id,),
|
||||
)
|
||||
if not result:
|
||||
return None
|
||||
# Remove the result after notifying
|
||||
self.db.execute_query(
|
||||
"DELETE FROM lottery_results WHERE ID = %s", (result["ID"],)
|
||||
)
|
||||
return (True, result["AMOUNT"])
|
||||
except Exception as e:
|
||||
logging.error(f"Error notifying lottery result: {e}")
|
||||
return None
|
||||
|
||||
@commands.command(
|
||||
name="buyticket",
|
||||
help=f"Buy one or more lottery tickets for yourself or a group.",
|
||||
)
|
||||
async def buy_ticket(
|
||||
self,
|
||||
ctx: commands.Context,
|
||||
ticket_type: str = "standard",
|
||||
amount: int = 1,
|
||||
group_id: str | None = None,
|
||||
member: discord.Member | None = None,
|
||||
):
|
||||
ticket_type = ticket_type.lower()
|
||||
if ticket_type not in TICKET_TYPES:
|
||||
await ctx.reply(
|
||||
f"Invalid ticket type. Choose from: {', '.join(TICKET_TYPES)}"
|
||||
)
|
||||
return
|
||||
if amount < 1 or amount > MAX_TICKETS_PER_USER:
|
||||
await ctx.reply(
|
||||
f"You can only buy between 1 and {MAX_TICKETS_PER_USER} tickets at once."
|
||||
)
|
||||
return
|
||||
user = member or ctx.author
|
||||
price = TICKET_TYPES[ticket_type]["price"] * amount
|
||||
try:
|
||||
# Notify about last draw if relevant (only if user is the winner)
|
||||
notify = self.notify_lottery_result(user.id)
|
||||
if notify:
|
||||
await ctx.reply(
|
||||
f"🎉 You won the last lottery! Jackpot: {notify[1]:,} coins.",
|
||||
mention_author=False,
|
||||
)
|
||||
|
||||
user_data = await bank_data(user)
|
||||
wallet = int(user_data.get("WALLET", 0))
|
||||
if wallet < price:
|
||||
await ctx.reply(
|
||||
f"You need at least {price} coins to buy {amount} {ticket_type} ticket(s).",
|
||||
mention_author=False,
|
||||
)
|
||||
return
|
||||
|
||||
if group_id:
|
||||
group_exists = self.db.fetch_one(
|
||||
"SELECT 1 FROM lottery_groups WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
in_group = self.db.fetch_one(
|
||||
"SELECT 1 FROM lottery_group_members WHERE group_id = %s AND user_id = %s",
|
||||
(group_id, user.id),
|
||||
)
|
||||
if not group_exists or not in_group:
|
||||
await ctx.reply(
|
||||
"You must be a member of the group to buy tickets for it."
|
||||
)
|
||||
return
|
||||
|
||||
user_ticket_count = self.db.fetch_one(
|
||||
"SELECT COUNT(*) as count FROM lottery_tickets WHERE USERID = %s",
|
||||
(user.id,),
|
||||
)["count"]
|
||||
if user_ticket_count + amount > MAX_TICKETS_PER_USER:
|
||||
await ctx.reply(
|
||||
f"You can only have {MAX_TICKETS_PER_USER} tickets per draw. You currently have {user_ticket_count}."
|
||||
)
|
||||
return
|
||||
|
||||
# Deduct ticket price
|
||||
await update_money(user, wallet=-price)
|
||||
self.add_to_jackpot(price)
|
||||
|
||||
# Store tickets in DB (one row per ticket for higher odds with multiple tickets)
|
||||
for _ in range(amount):
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_tickets (USERID, TIMESTAMP, TICKET_TYPE, group_id) VALUES (%s, %s, %s, %s)",
|
||||
(user.id, datetime.utcnow(), ticket_type, group_id),
|
||||
)
|
||||
|
||||
jackpot = self.get_jackpot()
|
||||
await ctx.reply(
|
||||
f"🎟️ {amount} {ticket_type.capitalize()} ticket(s) bought! Jackpot is now {jackpot:,} coins.",
|
||||
mention_author=False,
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error in buy_ticket: {e}")
|
||||
await ctx.reply(
|
||||
"An error occurred while buying your ticket(s).", mention_author=False
|
||||
)
|
||||
|
||||
@commands.command(name="lotterystats", help="Show current lottery stats.")
|
||||
async def lottery_stats(self, ctx: commands.Context):
|
||||
try:
|
||||
# Show last winner and their prize
|
||||
last_result = self.db.fetch_one(
|
||||
"SELECT * FROM lottery_results ORDER BY DRAW_TIME DESC LIMIT 1"
|
||||
)
|
||||
winner_text = "No draws yet."
|
||||
if last_result:
|
||||
winner = self.client.get_user(
|
||||
last_result["WINNER_ID"]
|
||||
) or await self.client.fetch_user(last_result["WINNER_ID"])
|
||||
winner_text = f"Last winner: {winner.mention if winner else 'Unknown'} ({last_result['AMOUNT']:,} coins)"
|
||||
|
||||
ticket_count = self.db.fetch_one(
|
||||
"SELECT COUNT(*) as count FROM lottery_tickets"
|
||||
)["count"]
|
||||
jackpot = self.get_jackpot()
|
||||
|
||||
# Check if the user has an unclaimed win
|
||||
unclaimed = self.db.fetch_one(
|
||||
"SELECT * FROM lottery_results WHERE WINNER_ID = %s AND CLAIMED = 0 ORDER BY DRAW_TIME DESC LIMIT 1",
|
||||
(ctx.author.id,),
|
||||
)
|
||||
winner_note = ""
|
||||
if unclaimed:
|
||||
# Mark as claimed and pay out
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_results SET CLAIMED = 1 WHERE ID = %s",
|
||||
(unclaimed["ID"],),
|
||||
)
|
||||
await update_money(ctx.author, wallet=unclaimed["AMOUNT"])
|
||||
winner_note = f"\n🎉 **You have won {unclaimed['AMOUNT']:,} coins! Your prize has been paid out.**"
|
||||
|
||||
await ctx.reply(
|
||||
f"{winner_text}\n"
|
||||
f"🎰 There are currently **{ticket_count}** tickets in the pool.\n"
|
||||
f"💰 Jackpot: **{jackpot:,}** coins.\n"
|
||||
f"Next draw in: {self.time_until_draw()}"
|
||||
f"{winner_note}",
|
||||
mention_author=False,
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error in lottery_stats: {e}")
|
||||
await ctx.reply(
|
||||
"An error occurred while fetching lottery stats.", mention_author=False
|
||||
)
|
||||
|
||||
def time_until_draw(self) -> str:
|
||||
now = datetime.utcnow()
|
||||
last_draw = self.get_last_draw_time()
|
||||
next_draw = last_draw + timedelta(hours=LOTTERY_INTERVAL_HOURS)
|
||||
remaining = next_draw - now
|
||||
if remaining.total_seconds() < 0:
|
||||
return "Drawing soon!"
|
||||
hours, remainder = divmod(int(remaining.total_seconds()), 3600)
|
||||
minutes, seconds = divmod(remainder, 60)
|
||||
return f"{hours}h {minutes}m {seconds}s"
|
||||
|
||||
@tasks.loop(minutes=1)
|
||||
async def lottery_draw(self):
|
||||
now = datetime.utcnow()
|
||||
last_draw = self.get_last_draw_time()
|
||||
if (now - last_draw).total_seconds() < LOTTERY_INTERVAL_HOURS * 3600:
|
||||
return # Not time yet
|
||||
|
||||
await self._run_lottery_draw()
|
||||
|
||||
@commands.command(name="testdraw", help="Manually trigger the lottery draw.")
|
||||
@commands.is_owner()
|
||||
async def testdraw(self, ctx: commands.Context):
|
||||
await ctx.send("Starting lottery draw...")
|
||||
await self._run_lottery_draw()
|
||||
|
||||
async def _run_lottery_draw(self):
|
||||
try:
|
||||
await self.client.wait_until_ready()
|
||||
tickets = self.db.fetch_all(
|
||||
"SELECT USERID, TICKET_TYPE FROM lottery_tickets"
|
||||
)
|
||||
jackpot = self.get_jackpot()
|
||||
if not tickets or jackpot <= 0:
|
||||
self.set_jackpot(self.get_jackpot() + ROLLOVER_BONUS)
|
||||
self.set_last_draw_time(datetime.utcnow())
|
||||
return
|
||||
|
||||
# Build weighted ticket list
|
||||
weighted_tickets = []
|
||||
for t in tickets:
|
||||
luck_row = self.db.fetch_one(
|
||||
"SELECT LUCK FROM lottery_luck WHERE USERID = %s", (t["USERID"],)
|
||||
)
|
||||
luck = luck_row["LUCK"] if luck_row else 0
|
||||
ticket_type_weight = TICKET_TYPES[t["TICKET_TYPE"]]["weight"]
|
||||
weight = ticket_type_weight * (1 + luck)
|
||||
weighted_tickets.extend([t["USERID"]] * weight)
|
||||
|
||||
winner_id = choice(weighted_tickets)
|
||||
# Find group for winning ticket BEFORE deleting tickets
|
||||
group_id = self.db.fetch_one(
|
||||
"SELECT group_id FROM lottery_tickets WHERE USERID = %s LIMIT 1",
|
||||
(winner_id,),
|
||||
)["group_id"]
|
||||
|
||||
self.db.execute_query("DELETE FROM lottery_tickets") # Reset for next round
|
||||
|
||||
if group_id:
|
||||
members = self.db.fetch_all(
|
||||
"SELECT user_id FROM lottery_group_members WHERE group_id = %s",
|
||||
(group_id,),
|
||||
)
|
||||
member_ids = [m["user_id"] for m in members]
|
||||
split_prize = (jackpot // 2) // len(member_ids)
|
||||
for uid in member_ids:
|
||||
member = self.client.get_user(uid) or await self.client.fetch_user(
|
||||
uid
|
||||
)
|
||||
await update_money(member, wallet=split_prize)
|
||||
# Store group win in results with WIN_TYPE='group'
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_results (WINNER_ID, AMOUNT, DRAW_TIME, CLAIMED, WIN_TYPE) VALUES (%s, %s, %s, 0, %s)",
|
||||
(group_id, jackpot // 2, datetime.utcnow(), "group"),
|
||||
)
|
||||
else:
|
||||
# Store solo win in results with WIN_TYPE='user'
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_results (WINNER_ID, AMOUNT, DRAW_TIME, CLAIMED, WIN_TYPE) VALUES (%s, %s, %s, 0, %s)",
|
||||
(winner_id, jackpot // 2, datetime.utcnow(), "user"),
|
||||
)
|
||||
# Carry over half the jackpot (rounded down)
|
||||
carryover = jackpot // 2
|
||||
self.set_jackpot(carryover)
|
||||
self.set_last_draw_time(datetime.utcnow())
|
||||
|
||||
# Reset winner's luck, increment others'
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_luck SET LUCK = 0 WHERE USERID = %s", (winner_id,)
|
||||
)
|
||||
self.db.execute_query(
|
||||
"UPDATE lottery_luck SET LUCK = LUCK + 1 WHERE USERID != %s",
|
||||
(winner_id,),
|
||||
)
|
||||
except Exception as e:
|
||||
logging.error(f"Error in _run_lottery_draw: {e}")
|
||||
|
||||
@lottery_draw.before_loop
|
||||
async def before_lottery_draw(self):
|
||||
await self.client.wait_until_ready()
|
||||
|
||||
@commands.command(name="lotteryhistory")
|
||||
async def lottery_history(self, ctx):
|
||||
results = self.db.fetch_all(
|
||||
"SELECT * FROM lottery_results ORDER BY DRAW_TIME DESC LIMIT 10"
|
||||
)
|
||||
if not results:
|
||||
await ctx.reply("No lottery draws yet.")
|
||||
return
|
||||
lines = []
|
||||
for res in results:
|
||||
if res.get("WIN_TYPE") == "group":
|
||||
lines.append(
|
||||
f"{res['DRAW_TIME'].strftime('%Y-%m-%d')}: Group `{res['WINNER_ID']}` won {res['AMOUNT']:,} coins"
|
||||
)
|
||||
else:
|
||||
winner = self.client.get_user(
|
||||
res["WINNER_ID"]
|
||||
) or await self.client.fetch_user(res["WINNER_ID"])
|
||||
lines.append(
|
||||
f"{res['DRAW_TIME'].strftime('%Y-%m-%d')}: {winner.mention if winner else 'Unknown'} won {res['AMOUNT']:,} coins"
|
||||
)
|
||||
await ctx.reply("\n".join(lines))
|
||||
|
||||
@commands.command(name="lotteryleaderboard")
|
||||
async def lottery_leaderboard(self, ctx):
|
||||
winners = self.db.fetch_all(
|
||||
"SELECT WINNER_ID, COUNT(*) as wins, SUM(AMOUNT) as total FROM lottery_results GROUP BY WINNER_ID ORDER BY wins DESC LIMIT 10"
|
||||
)
|
||||
if not winners:
|
||||
await ctx.reply("No winners yet.")
|
||||
return
|
||||
lines = []
|
||||
for w in winners:
|
||||
user = self.client.get_user(w["WINNER_ID"]) or await self.client.fetch_user(
|
||||
w["WINNER_ID"]
|
||||
)
|
||||
lines.append(
|
||||
f"{user.mention if user else 'Unknown'}: {w['wins']} wins, {w['total']:,} coins"
|
||||
)
|
||||
await ctx.reply("\n".join(lines))
|
||||
|
||||
@commands.command(name="initluck")
|
||||
@commands.is_owner()
|
||||
async def init_luck(self, ctx):
|
||||
"""Initialize or reset the luck of a user."""
|
||||
user = ctx.author
|
||||
self.db.execute_query(
|
||||
"INSERT IGNORE INTO lottery_luck (USERID, LUCK) VALUES (%s, 0)", (user.id,)
|
||||
)
|
||||
await ctx.reply(f"Your luck has been initialized/reset.")
|
||||
|
||||
@commands.command(name="creategroup")
|
||||
async def create_group(self, ctx, group_id: str):
|
||||
exists = self.db.fetch_one(
|
||||
"SELECT 1 FROM lottery_groups WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
if exists:
|
||||
await ctx.reply("A group with that ID already exists.")
|
||||
return
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_groups (group_id, creator_id) VALUES (%s, %s)",
|
||||
(group_id, ctx.author.id),
|
||||
)
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_group_members (group_id, user_id) VALUES (%s, %s)",
|
||||
(group_id, ctx.author.id),
|
||||
)
|
||||
await ctx.reply(f"Group `{group_id}` created and you have joined it.")
|
||||
|
||||
@commands.command(name="joingroup")
|
||||
async def join_group(self, ctx, group_id: str):
|
||||
exists = self.db.fetch_one(
|
||||
"SELECT 1 FROM lottery_groups WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
if not exists:
|
||||
await ctx.reply("That group does not exist.")
|
||||
return
|
||||
already = self.db.fetch_one(
|
||||
"SELECT 1 FROM lottery_group_members WHERE group_id = %s AND user_id = %s",
|
||||
(group_id, ctx.author.id),
|
||||
)
|
||||
if already:
|
||||
await ctx.reply("You are already in this group.")
|
||||
return
|
||||
self.db.execute_query(
|
||||
"INSERT INTO lottery_group_members (group_id, user_id) VALUES (%s, %s)",
|
||||
(group_id, ctx.author.id),
|
||||
)
|
||||
await ctx.reply(f"You have joined group `{group_id}`.")
|
||||
|
||||
@commands.command(name="leavegroup")
|
||||
async def leave_group(self, ctx, group_id: str):
|
||||
self.db.execute_query(
|
||||
"DELETE FROM lottery_group_members WHERE group_id = %s AND user_id = %s",
|
||||
(group_id, ctx.author.id),
|
||||
)
|
||||
await ctx.reply(f"You have left group `{group_id}`.")
|
||||
|
||||
@commands.command(name="deletegroup")
|
||||
async def delete_group(self, ctx, group_id: str):
|
||||
# Check if group exists and if user is creator
|
||||
group = self.db.fetch_one(
|
||||
"SELECT creator_id FROM lottery_groups WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
if not group:
|
||||
await ctx.reply("That group does not exist.")
|
||||
return
|
||||
if group["creator_id"] != ctx.author.id:
|
||||
await ctx.reply("Only the group creator can delete this group.")
|
||||
return
|
||||
# Check if group is empty (no members except possibly the creator)
|
||||
members = self.db.fetch_all(
|
||||
"SELECT user_id FROM lottery_group_members WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
if len(members) > 1 or (
|
||||
len(members) == 1 and members[0]["user_id"] != ctx.author.id
|
||||
):
|
||||
await ctx.reply(
|
||||
"You can only delete a group if it is empty (no members except you)."
|
||||
)
|
||||
return
|
||||
# Delete group and membership
|
||||
self.db.execute_query(
|
||||
"DELETE FROM lottery_group_members WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
self.db.execute_query(
|
||||
"DELETE FROM lottery_groups WHERE group_id = %s", (group_id,)
|
||||
)
|
||||
await ctx.reply(f"Group `{group_id}` has been deleted.")
|
||||
|
||||
@commands.command(name="refundtickets")
|
||||
async def refund_tickets(self, ctx, amount: int = 1):
|
||||
user = ctx.author
|
||||
tickets = self.db.fetch_all(
|
||||
"SELECT * FROM lottery_tickets WHERE USERID = %s", (user.id,)
|
||||
)
|
||||
if not tickets:
|
||||
await ctx.reply("You have no tickets to refund for this draw.")
|
||||
return
|
||||
|
||||
if amount is None:
|
||||
amount = len(tickets)
|
||||
if amount < 1 or amount > len(tickets):
|
||||
await ctx.reply(
|
||||
f"You can only refund between 1 and {len(tickets)} tickets."
|
||||
)
|
||||
return
|
||||
|
||||
# Refund only the specified amount
|
||||
tickets_to_refund = tickets[:amount]
|
||||
total_refund = 0
|
||||
ticket_ids = []
|
||||
for ticket in tickets_to_refund:
|
||||
price = TICKET_TYPES[ticket["TICKET_TYPE"]]["price"]
|
||||
refund = int(price * 0.8)
|
||||
total_refund += refund
|
||||
ticket_ids.append(ticket["ID"])
|
||||
|
||||
# Remove only the refunded tickets
|
||||
format_strings = ",".join(["%s"] * len(ticket_ids))
|
||||
self.db.execute_query(
|
||||
f"DELETE FROM lottery_tickets WHERE ID IN ({format_strings})",
|
||||
tuple(ticket_ids),
|
||||
)
|
||||
await update_money(user, wallet=total_refund)
|
||||
await ctx.reply(
|
||||
f"{amount} ticket(s) refunded for {total_refund:,} coins (80% of purchase price)."
|
||||
)
|
||||
|
||||
|
||||
async def setup(client):
|
||||
await client.add_cog(Lottery(client))
|
||||
Reference in New Issue
Block a user