Post
Topic
Board Gambling discussion
Merits 8 from 2 users
Topic OP
Keeping a betting log
by
mcdouglasx
on 23/02/2025, 22:23:22 UTC
⭐ Merited by ChiBitCTy (5) ,romero121 (3)
Have you thought about keeping a record of bets, monthly wins and losses, to track this?.

Is such record-keeping important to you, or do you not consider it crucial for your economy?.


This python script might be an example of how you could do it.




Code:
import tkinter as tk
from tkinter import messagebox
from datetime import datetime

class BettingApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Bet-Talk")
        self.root.configure(bg='orange')
        self.root.geometry("700x800")

        self.total_balance = 0.0
        self.bets = []
        self.bet_count = 0

        self.create_widgets()
        self.update_balances()
        self.update_bet_info()
        self.load_bets()

    def create_widgets(self):
        self.bet_info_label = tk.Label(self.root, text="Bet Number: 0 | Date: -", bg='orange')
        self.bet_info_label.pack(pady=5)

        self.amount_entry = self.create_label_entry("Amount Bet:")
        self.prize_entry = self.create_label_entry("Prize:")

        self.add_button = tk.Button(self.root, text="Add Bet", command=self.add_entry)
        self.add_button.pack(pady=10)

        self.delete_button = tk.Button(self.root, text="Delete Bet", command=self.delete_bet)
        self.delete_button.pack(pady=10)

        self.daily_balance_label = tk.Label(self.root, text=f"Daily Balance: 0.0", bg='orange', font=("Helvetica", 16))
        self.daily_balance_label.pack(pady=10)

        self.daily_amount_bet_label = tk.Label(self.root, text=f"Amount Bet: 0.0", bg='orange', font=("Helvetica", 12))
        self.daily_amount_bet_label.pack(pady=10)

        self.daily_net_gain_label = tk.Label(self.root, text=f"Net Gain: 0.0", bg='orange', font=("Helvetica", 12))
        self.daily_net_gain_label.pack(pady=10)

        self.monthly_balance_label = tk.Label(self.root, text=f"Monthly Balance: 0.0", bg='orange', font=("Helvetica", 16))
        self.monthly_balance_label.pack(pady=10)

        self.monthly_amount_bet_label = tk.Label(self.root, text=f"Amount Bet: 0.0", bg='orange', font=("Helvetica", 12))
        self.monthly_amount_bet_label.pack(pady=10)

        self.monthly_net_gain_label = tk.Label(self.root, text=f"Net Gain: 0.0", bg='orange', font=("Helvetica", 12))
        self.monthly_net_gain_label.pack(pady=10)

        self.balance_label = tk.Label(self.root, text=f"Total Balance: {self.total_balance:.2f}", bg='orange', font=("Helvetica", 16))
        self.balance_label.pack(pady=20)

        self.bet_listbox = tk.Listbox(self.root)
        self.bet_listbox.pack(pady=10, fill=tk.BOTH, expand=True)
        self.bet_listbox.bind("<Double-Button-1>", self.edit_bet)

    def create_label_entry(self, text):
        frame = tk.Frame(self.root, bg='orange')
        tk.Label(frame, text=text, bg='orange').pack(pady=5)
        entry = tk.Entry(frame)
        entry.pack(pady=5)
        frame.pack(pady=5)
        return entry

    def update_balances(self):
        self.update_balance()
        self.update_daily_balance()
        self.update_monthly_balance()

    def update_balance(self):
        self.total_balance = sum(bet[5] for bet in self.bets)
        self.balance_label.config(text=f"Total Balance: {self.total_balance:.2f}")

    def update_daily_balance(self):
        daily_balance = {}
        daily_amount_bet = {}
        daily_net_gain = {}
        today = datetime.now().strftime("%Y-%m-%d")
        for bet in self.bets:
            day = bet[1][:10]
            amount_bet = bet[2]
            net_gain = bet[5]
            if day in daily_balance:
                daily_balance[day] += net_gain
                daily_amount_bet[day] += amount_bet
                daily_net_gain[day] += net_gain
            else:
                daily_balance[day] = net_gain
                daily_amount_bet[day] = amount_bet
                daily_net_gain[day] = net_gain

        balance_today = daily_balance.get(today, 0.0)
        amount_bet_today = daily_amount_bet.get(today, 0.0)
        net_gain_today = daily_net_gain.get(today, 0.0)
        self.daily_balance_label.config(text=f"Daily Balance: {balance_today:.2f}")
        self.daily_amount_bet_label.config(text=f"Amount Bet: {amount_bet_today:.2f}")
        self.daily_net_gain_label.config(text=f"Net Gain: {net_gain_today:.2f}")

    def update_monthly_balance(self):
        monthly_balance = {}
        monthly_amount_bet = {}
        monthly_net_gain = {}
        current_month = datetime.now().strftime("%Y-%m")
        for bet in self.bets:
            month = bet[1][:7]
            amount_bet = bet[2]
            net_gain = bet[5]
            if month in monthly_balance:
                monthly_balance[month] += net_gain
                monthly_amount_bet[month] += amount_bet
                monthly_net_gain[month] += net_gain
            else:
                monthly_balance[month] = net_gain
                monthly_amount_bet[month] = amount_bet
                monthly_net_gain[month] = net_gain

        balance_month = monthly_balance.get(current_month, 0.0)
        amount_bet_month = monthly_amount_bet.get(current_month, 0.0)
        net_gain_month = monthly_net_gain.get(current_month, 0.0)
        self.monthly_balance_label.config(text=f"Monthly Balance: {balance_month:.2f}")
        self.monthly_amount_bet_label.config(text=f"Amount Bet: {amount_bet_month:.2f}")
        self.monthly_net_gain_label.config(text=f"Net Gain: {net_gain_month:.2f}")

    def add_entry(self):
        try:
            bet_number = self.bet_count
            bet_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            amount = float(self.amount_entry.get())
            prize = float(self.prize_entry.get())
            win = None

            net_gain = 0
            self.bets.append((bet_number, bet_date, amount, prize, win, net_gain))
            self.bet_count += 1

            self.amount_entry.delete(0, tk.END)
            self.prize_entry.delete(0, tk.END)

            self.update_balances()
            self.update_listbox()
            self.update_bet_info()
            self.write_to_file()

            messagebox.showinfo("Success", f"Bet {bet_number} added successfully!")
        except ValueError:
            messagebox.showerror("Error", "Please enter valid numbers in amount bet and prize.")

    def delete_bet(self):
        selected = self.bet_listbox.curselection()
        if not selected:
            messagebox.showerror("Error", "Please select a bet to delete.")
            return
        index = selected[0]
        bet = self.bets.pop(index)

        self.update_balances()
        self.update_listbox()
        self.write_to_file()

    def edit_bet(self, event):
        selected = self.bet_listbox.curselection()
        if not selected:
            return
        index = selected[0]
        bet = self.bets[index]

        edit_window = tk.Toplevel(self.root)
        edit_window.title("Edit Bet")
        edit_window.configure(bg='orange')
        edit_window.geometry("400x400")

        tk.Label(edit_window, text=f"Bet {bet[0]}", bg='orange').pack(pady=5)
        tk.Label(edit_window, text=f"Date: {bet[1]}", bg='orange').pack(pady=5)

        tk.Label(edit_window, text="Amount Bet:", bg='orange').pack(pady=5)
        amount_entry = tk.Entry(edit_window)
        amount_entry.insert(0, str(bet[2]))
        amount_entry.pack(pady=5)

        tk.Label(edit_window, text="Prize:", bg='orange').pack(pady=5)
        prize_entry = tk.Entry(edit_window)
        prize_entry.insert(0, str(bet[3]))
        prize_entry.pack(pady=5)

        tk.Label(edit_window, text="Result:", bg='orange').pack(pady=5)
        win_var = tk.IntVar(value=1 if bet[4] else (0 if bet[4] is False else -1))
        win_check = tk.Checkbutton(edit_window, text="Won", variable=win_var, onvalue=1, bg='orange')
        win_check.pack(pady=5)

        lose_check = tk.Checkbutton(edit_window, text="Lost", variable=win_var, onvalue=0, bg='orange')
        lose_check.pack(pady=5)

        def save_changes():
            try:
                amount = float(amount_entry.get())
                prize = float(prize_entry.get())
                win = win_var.get()
                win = True if win == 1 else (False if win == 0 else None)

                net_gain = prize - amount if win else (-amount if win is False else 0)
                self.bets[index] = (bet[0], bet[1], amount, prize, win, net_gain)

                self.update_balances()
                self.update_listbox()
                self.write_to_file()
                edit_window.destroy()
            except ValueError:
                messagebox.showerror("Error", "Please enter valid numbers in amount bet and prize.")

        tk.Button(edit_window, text="Save Changes", command=save_changes).pack(pady=10)

    def update_listbox(self):
        self.bet_listbox.delete(0, tk.END)
        for bet in self.bets:
            win_status = "Won" if bet[4] else ("Lost" if bet[4] is False else "Pending")
            self.bet_listbox.insert(tk.END, f"Bet {bet[0]} | Date: {bet[1]} | Amount: {bet[2]:.2f} | Prize: {bet[3]:.2f} | Result: {win_status} | Net Gain/Loss: {bet[5]:.2f}")

    def update_bet_info(self):
        if self.bets:
            latest_bet = self.bets[-1]
            self.bet_info_label.config(text=f"Bet Number: {latest_bet[0]} | Date: {latest_bet[1]}")
        else:
            self.bet_info_label.config(text="Bet Number: 0 | Date: -")

    def write_to_file(self):
        with open("betting_balance.txt", "w") as file:
            for bet in self.bets:
                win_status = "Won" if bet[4] else ("Lost" if bet[4] is False else "Pending")
                file.write(f"Bet {bet[0]} | Date: {bet[1]}\n")
                file.write(f"Amount Bet: {bet[2]:.2f}\n")
                file.write(f"Prize: {bet[3]:.2f}\n")
                file.write(f"Result: {win_status}\n")
                file.write(f"Net Gain/Loss: {bet[5]:.2f}\n")
                file.write("\n")

    def load_bets(self):
        try:
            with open("betting_balance.txt", "r") as file:
                lines = file.readlines()
                self.bets = []
                self.total_balance = 0.0
                for line in lines:
                    if line.startswith("Bet"):
                        parts = line.strip().split("|")
                        if len(parts) > 1:
                            bet_number = int(parts[0].split(" ")[1])
                            bet_date = parts[1].split(": ")[1].strip()
                            self.bets.append([bet_number, bet_date, 0.0, 0.0, None, 0.0])
                    elif line.startswith("Amount Bet"):
                        parts = line.strip().split(": ")
                        if len(parts) > 1:
                            amount = float(parts[1])
                            self.bets[-1][2] = amount
                    elif line.startswith("Prize"):
                        parts = line.strip().split(": ")
                        if len(parts) > 1:
                            prize = float(parts[1])
                            self.bets[-1][3] = prize
                    elif line.startswith("Result"):
                        parts = line.strip().split(": ")
                        if len(parts) > 1:
                            result = parts[1]
                            if result == "Won":
                                self.bets[-1][4] = True
                            elif result == "Lost":
                                self.bets[-1][4] = False
                            else:
                                self.bets[-1][4] = None
                    elif line.startswith("Net Gain/Loss"):
                        parts = line.strip().split(": ")
                        if len(parts) > 1:
                            net_gain = float(parts[1])
                            self.bets[-1][5] = net_gain
                            self.total_balance += net_gain
                self.bet_count = len(self.bets)
                self.update_listbox()
                self.update_balances()
                self.update_bet_info()
        except FileNotFoundError:
            pass

root = tk.Tk()
app = BettingApp(root)
root.mainloop()