Implementacion de juego Gamblingº

MainController.py

@@ -4,6 +4,7 @@ from MainView import MainView
 from models.NetworkingScanner import NetworkScanner
 from models.Sniffer import packet_callback, sniff
 from models.MusicPlayer import MusicPlayerModel
+from models.GamblingGameModel import GamblingGameModel
 import tkinter as tk
 import time
 import datetime
@@ -17,6 +18,9 @@ class MainController:
         self.connect_events()
         self.start_system_updates()
         self.music_model = MusicPlayerModel()
+        self.game_model = GamblingGameModel()
+        self.roulette_running = False
+        self.roulette_thread = None
 
     def connect_events(self):
         """Conecta los eventos de la vista con las funciones del controlador."""
@@ -29,6 +33,10 @@ class MainController:
         self.view.button_stop_music.config(command=self.stop_song)
         self.view.button_refresh_music.config(command=self.refresh_songs)
         
+        """Conecta los eventos de la vista con las funciones del controlador."""
+        self.view.button_start_roulette.config(command=self.start_roulette)
+        self.view.button_stop_roulette.config(command=self.stop_roulette)
+        
         
     def start_sniffer_thread(self):
         """Inicia el sniffer en un hilo separado."""
@@ -173,3 +181,73 @@ class MainController:
         self.load_songs()
         print(self.message)
 
+
+    def start_roulette(self):
+        """Inicia el giro de la ruleta en un hilo."""
+        if self.roulette_running:
+            return
+
+        try:
+            bet = int(self.view.bet_entry.get())
+            chosen_number = int(self.view.number_entry.get())
+        except ValueError:
+            self.view.result_label.config(text="Por favor, ingresa valores numéricos válidos.", foreground="red")
+            return
+
+        if bet <= 0 or chosen_number < 1 or chosen_number > 10:
+            self.view.result_label.config(
+                text="La apuesta debe ser mayor a 0 y elige un número entre 1 y 10.", foreground="red"
+            )
+            return
+
+        if bet > self.game_model.get_balance():
+            self.view.result_label.config(text="No tienes suficiente saldo para esta apuesta.", foreground="red")
+            return
+
+        self.game_model.set_bet(bet)
+        self.game_model.set_chosen_number(chosen_number)
+        self.roulette_running = True
+        self.view.button_start_roulette.config(state="disabled")
+        self.view.button_stop_roulette.config(state="normal")
+
+        # Inicia el hilo de la ruleta
+        self.roulette_thread = threading.Thread(target=self.spin_roulette)
+        self.roulette_thread.start()
+        
+    def spin_roulette(self):
+        """Simula el giro continuo de la ruleta."""
+        while self.roulette_running:
+            self.game_model.spin_roulette()
+            roulette_number = self.game_model.get_roulette_number()
+            self.view.roulette_label.config(text=f"Ruleta: {roulette_number}")
+            time.sleep(0.1)
+    
+    def stop_roulette(self):
+        """Detiene la ruleta y evalúa el resultado."""
+        if not self.roulette_running:
+            return
+
+        self.roulette_running = False
+        self.view.button_start_roulette.config(state="normal")
+        self.view.button_stop_roulette.config(state="disabled")
+
+        # Evaluar el resultado del juego
+        won, amount = self.game_model.evaluate_result()
+        if won:
+            self.view.result_label.config(
+                text=f"¡Ganaste! Número: {self.game_model.get_roulette_number()}. Ganaste $ {amount}.", foreground="green"
+            )
+        else:
+            self.view.result_label.config(
+                text=f"Perdiste. Número: {self.game_model.get_roulette_number()}. Perdiste $ {amount}.", foreground="red"
+            )
+
+        # Actualizar saldo en la vista
+        self.view.balance_label.config(text=f"Saldo: ${self.game_model.get_balance()}")
+
+        # Verificar saldo
+        if self.game_model.get_balance() <= 0:
+            self.view.result_label.config(
+                text="¡Te quedaste sin saldo! Gracias por jugar.", foreground="red"
+            )
+            self.view.button_start_roulette.config(state="disabled")

MainView.py

@@ -59,12 +59,16 @@ class MainView:
         self.notebook.add(tab3, text="Sniffer")
         self.create_sniffer_ui(tab3)
 
-        # Solapas 4-5: Vacías
-        for i in range(4, 6):
-            tab = ttk.Frame(self.notebook)
-            self.notebook.add(tab, text=f"Solapa {i}")
-            label = ttk.Label(tab, text=f"Contenido de la Solapa {i}")
-            label.pack(pady=10)
+        # Solapa 4: Juego de Azar
+        tab4 = ttk.Frame(self.notebook)
+        self.notebook.add(tab4, text="Juego de Azar")
+        self.create_gambling_game_ui(tab4)
+
+        # Solapa 5 vacía
+        tab5 = ttk.Frame(self.notebook)
+        self.notebook.add(tab5, text="Solapa 5")
+        label = ttk.Label(tab5, text="Contenido de la Solapa 5")
+        label.pack(pady=10)
 
     def create_tracker_ui(self, tab):
         """Crea la interfaz de usuario para el rastreador de IP en la solapa 1."""
@@ -151,3 +155,37 @@ class MainView:
         if songs:
             for song in songs:
                 self.music_listbox.insert(tk.END, song)
+                
+    def create_gambling_game_ui(self, tab):
+        """Crea la interfaz de usuario para el juego de azar en la Solapa 4."""
+        label = ttk.Label(tab, text="Juego de Azar - Ruleta", font=("Arial", 16))
+        label.pack(pady=10)
+
+        # Saldo actual
+        self.balance_label = ttk.Label(tab, text="Saldo: $100", font=("Arial", 12))
+        self.balance_label.pack(pady=5)
+
+        # Entrada para la apuesta
+        ttk.Label(tab, text="Apuesta ($):").pack(pady=5)
+        self.bet_entry = ttk.Entry(tab, width=20)
+        self.bet_entry.pack(pady=5)
+
+        # Entrada para el número
+        ttk.Label(tab, text="Elige un número (1-10):").pack(pady=5)
+        self.number_entry = ttk.Entry(tab, width=20)
+        self.number_entry.pack(pady=5)
+
+        # Botones
+        self.button_start_roulette = ttk.Button(tab, text="Iniciar Ruleta")
+        self.button_start_roulette.pack(pady=10)
+
+        self.button_stop_roulette = ttk.Button(tab, text="Detener Ruleta", state="disabled")
+        self.button_stop_roulette.pack(pady=5)
+
+        # Resultado del juego
+        self.roulette_label = ttk.Label(tab, text="Ruleta: ---", font=("Arial", 14), foreground="red")
+        self.roulette_label.pack(pady=10)
+
+        self.result_label = ttk.Label(tab, text="", font=("Arial", 12), foreground="blue")
+        self.result_label.pack(pady=10)
+

models/GamblingGameModel.py

@@ -0,0 +1,40 @@
+import random
+
+
+class GamblingGameModel:
+    def __init__(self):
+        """Inicializa el modelo con un saldo inicial."""
+        self.balance = 100
+        self.bet = 0
+        self.chosen_number = 0
+        self.roulette_number = None
+
+    def set_bet(self, bet):
+        """Establece la apuesta."""
+        self.bet = bet
+
+    def set_chosen_number(self, number):
+        """Establece el número elegido."""
+        self.chosen_number = number
+
+    def spin_roulette(self):
+        """Genera un número aleatorio para la ruleta."""
+        self.roulette_number = random.randint(1, 10)
+
+    def evaluate_result(self):
+        """Evalúa si el jugador gana o pierde."""
+        if self.chosen_number == self.roulette_number:
+            winnings = self.bet * 2
+            self.balance += winnings
+            return True, winnings
+        else:
+            self.balance -= self.bet
+            return False, self.bet
+
+    def get_balance(self):
+        """Retorna el saldo actual."""
+        return self.balance
+
+    def get_roulette_number(self):
+        """Retorna el número actual de la ruleta."""
+        return self.roulette_number

pruebas.py

@@ -1,60 +1,123 @@
 import tkinter as tk
-from tkinter import messagebox, Listbox
-from models.MusicPlayer import MusicPlayerModel
+from tkinter import messagebox
+import threading
+import random
+import time
 
-class MusicPlayerApp:
+
+class GamblingGameWithThreads:
     def __init__(self, root):
         self.root = root
-        self.root.title("Reproductor de Música")
-        self.root.geometry("400x300")
+        self.root.title("Juego de Azar - Ruleta con Hilos")
+        self.root.geometry("400x400")
 
-        self.player = MusicPlayerModel()
-        self.songs, self.message = self.player.load_songs()
+        # Variables del juego
+        self.balance = 100
+        self.roulette_number = None
+        self.roulette_running = False
+        self.roulette_thread = None
 
-        # Lista de canciones
-        self.song_listbox = Listbox(self.root, bg="white", fg="black", font=("Arial", 12))
-        self.song_listbox.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
-        self.refresh_song_list()
+        # Etiqueta de saldo
+        self.balance_label = tk.Label(self.root, text=f"Saldo: $ {self.balance}", font=("Arial", 14))
+        self.balance_label.pack(pady=10)
 
-        # Botones
-        self.button_frame = tk.Frame(self.root)
-        self.button_frame.pack(pady=10)
+        # Entrada para la apuesta
+        tk.Label(self.root, text="Tu Apuesta ($):", font=("Arial", 12)).pack()
+        self.bet_entry = tk.Entry(self.root, width=10, font=("Arial", 12))
+        self.bet_entry.pack(pady=5)
 
-        self.play_button = tk.Button(self.button_frame, text="Reproducir", command=self.play_song, width=12)
-        self.play_button.grid(row=0, column=0, padx=5)
+        # Entrada para elegir número
+        tk.Label(self.root, text="Elige un número (1-10):", font=("Arial", 12)).pack()
+        self.number_entry = tk.Entry(self.root, width=10, font=("Arial", 12))
+        self.number_entry.pack(pady=5)
 
-        self.stop_button = tk.Button(self.button_frame, text="Detener", command=self.stop_song, width=12)
-        self.stop_button.grid(row=0, column=1, padx=5)
+        # Botones de control
+        self.start_button = tk.Button(self.root, text="Iniciar Ruleta", font=("Arial", 12), command=self.start_roulette)
+        self.start_button.pack(pady=10)
 
-        self.refresh_button = tk.Button(self.button_frame, text="Actualizar", command=self.refresh_song_list, width=12)
-        self.refresh_button.grid(row=0, column=2, padx=5)
+        self.stop_button = tk.Button(self.root, text="Detener Ruleta", font=("Arial", 12), state="disabled", command=self.stop_roulette)
+        self.stop_button.pack(pady=5)
 
-    def refresh_song_list(self):
-        """Carga las canciones en el Listbox desde la carpeta resources."""
-        self.songs, self.message = self.player.load_songs()
-        self.song_listbox.delete(0, tk.END)
-        if self.songs:
-            for song in self.songs:
-                self.song_listbox.insert(tk.END, song)
-        else:
-            messagebox.showinfo("Información", self.message)
+        # Resultado del juego
+        self.result_label = tk.Label(self.root, text="", font=("Arial", 12), fg="blue")
+        self.result_label.pack(pady=10)
 
-    def play_song(self):
-        """Reproduce la canción seleccionada."""
-        selected = self.song_listbox.curselection()
-        if not selected:
-            messagebox.showwarning("Advertencia", "Selecciona una canción para reproducir.")
+        # Número de la ruleta en tiempo real
+        self.roulette_label = tk.Label(self.root, text="Ruleta: ---", font=("Arial", 16), fg="red")
+        self.roulette_label.pack(pady=10)
+
+    def start_roulette(self):
+        """Inicia el giro de la ruleta en un hilo."""
+        if self.roulette_running:
+            messagebox.showwarning("Advertencia", "La ruleta ya está girando.")
             return
-        song_name = self.song_listbox.get(selected)
-        message = self.player.play_song(song_name)
-        messagebox.showinfo("Reproduciendo", message)
 
-    def stop_song(self):
-        """Detiene la reproducción."""
-        message = self.player.stop_song()
-        messagebox.showinfo("Detenido", message)
+        try:
+            bet = int(self.bet_entry.get())
+            chosen_number = int(self.number_entry.get())
+        except ValueError:
+            messagebox.showerror("Error", "Por favor, ingresa valores numéricos válidos.")
+            return
+
+        if bet <= 0 or chosen_number < 1 or chosen_number > 10:
+            messagebox.showwarning("Advertencia", "La apuesta debe ser mayor a $0 y elige un número entre 1 y 10.")
+            return
+
+        if bet > self.balance:
+            messagebox.showwarning("Advertencia", "No tienes suficiente saldo para esta apuesta.")
+            return
+
+        self.bet = bet
+        self.chosen_number = chosen_number
+        self.roulette_running = True
+        self.start_button.config(state="disabled")
+        self.stop_button.config(state="normal")
+
+        # Crear y arrancar el hilo de la ruleta
+        self.roulette_thread = threading.Thread(target=self.spin_roulette)
+        self.roulette_thread.start()
+
+    def spin_roulette(self):
+        """Simula el giro continuo de la ruleta."""
+        while self.roulette_running:
+            self.roulette_number = random.randint(1, 10)
+            self.roulette_label.config(text=f"Ruleta: {self.roulette_number}")
+            time.sleep(0.1)
+
+    def stop_roulette(self):
+        """Detiene la ruleta y evalúa el resultado del juego."""
+        if not self.roulette_running:
+            return
+
+        self.roulette_running = False
+        self.start_button.config(state="normal")
+        self.stop_button.config(state="disabled")
+
+        # Evaluar resultado
+        if self.chosen_number == self.roulette_number:
+            winnings = self.bet * 2
+            self.balance += winnings
+            self.result_label.config(
+                text=f"¡Ganaste! El número fue {self.roulette_number}. Ganaste $ {winnings}.",
+                fg="green",
+            )
+        else:
+            self.balance -= self.bet
+            self.result_label.config(
+                text=f"Perdiste. El número fue {self.roulette_number}. Perdiste $ {self.bet}.",
+                fg="red",
+            )
+
+        # Actualizar saldo
+        self.balance_label.config(text=f"Saldo: $ {self.balance}")
+
+        # Revisar si el jugador se quedó sin saldo
+        if self.balance <= 0:
+            messagebox.showinfo("Juego Terminado", "¡Te quedaste sin saldo! Gracias por jugar.")
+            
+
 
 if __name__ == "__main__":
     root = tk.Tk()
-    app = MusicPlayerApp(root)
+    app = GamblingGameWithThreads(root)
     root.mainloop()