client and update .gitignore

.gitignore

@@ -0,0 +1,4 @@
+.venv/
+__pycache__/
+glares.json
+users.json

client.py

@@ -0,0 +1,362 @@
+import asyncio
+import json
+import random
+
+import aiohttp
+import websockets
+
+# base = "araeynn-glorified.hf.space"  # For production
+base = "localhost:7860"  # For local testing
+API_URL = f"https://{base}"
+if base.startswith("localhost"):
+    API_URL = f"http://{base}"
+    WS_URL_ROULETTE = f"ws://{base}/ws/roulette"
+    WS_URL_SPINNER = f"ws://{base}/ws/spinner"
+    WS_URL_CRASH = f"ws://{base}/ws/crash"
+    WS_URL_MINES = f"ws://{base}/ws/mines"
+    WS_URL_TOWER = f"ws://{base}/ws/tower"
+else:
+    WS_URL_ROULETTE = f"wss://{base}/ws/roulette"
+    WS_URL_SPINNER = f"wss://{base}/ws/spinner"
+    WS_URL_CRASH = f"wss://{base}/ws/crash"
+    WS_URL_MINES = f"wss://{base}/ws/mines"
+    WS_URL_TOWER = f"wss://{base}/ws/tower"
+
+USERNAME = "testuser"
+PASSWORD = "testpass"
+
+
+async def register_user():
+    async with aiohttp.ClientSession() as session:
+        data = {"username": USERNAME, "password": PASSWORD}
+        async with session.post(f"{API_URL}/register", data=data) as resp:
+            # If already registered, the endpoint will return an error.
+            if resp.status != 200:
+                text = await resp.text()
+                print(f"Register failed (maybe already registered): {text}")
+            else:
+                res = await resp.json()
+                print(f"Register response: {res}")
+
+
+async def play_roulette():
+    async with websockets.connect(WS_URL_ROULETTE) as websocket:
+        # Send authentication
+        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        await websocket.send(json.dumps(auth_msg))
+        # Receive welcome message with balance
+        welcome = await websocket.recv()
+        data = json.loads(welcome)
+        print(f"Initial connection: {data}")
+
+        # Wait 2 seconds
+        await asyncio.sleep(1)
+
+        # Bet 1 on red
+        bet_msg = {"bet": {"red": 1}}
+        print("Placing bet of 1 on red...")
+        await websocket.send(json.dumps(bet_msg))
+        response = await websocket.recv()
+        print(f"Bet response: {json.loads(response)}")
+
+        # Wait 2 seconds again
+        await asyncio.sleep(2)
+
+        # Bet 1 on red again
+        bet_msg = {"bet": {"red": 1}}
+        print("Placing another bet of 1 on red...")
+        await websocket.send(json.dumps(bet_msg))
+        response = await websocket.recv()
+        print(f"Bet response: {json.loads(response)}")
+
+
+async def play_spinner():
+    # First get current balance to bet all-in
+    async with aiohttp.ClientSession() as session:
+        params = {"username": USERNAME, "password": PASSWORD}
+        async with session.get(f"{API_URL}/glares", params=params) as resp:
+            balance_data = await resp.json()
+            balance = balance_data.get("glares", 0)
+            print(f"Current balance: {balance}")
+
+    # Now connect to spinner and bet all-in
+    async with websockets.connect(WS_URL_SPINNER) as websocket:
+        # Send authentication
+        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        await websocket.send(json.dumps(auth_msg))
+
+        # Receive welcome message
+        welcome = await websocket.recv()
+        data = json.loads(welcome)
+        print(f"Spinner connection: {data}")
+
+        # Get current balance for all-in bet
+        current_balance = data.get("glares", balance)
+
+        # Wait 2 seconds
+        await asyncio.sleep(2)
+
+        # All-in bet
+        bet_msg = {"bet": int(current_balance)}
+        print(f"Placing ALL-IN bet of {int(current_balance)} on spinner...")
+        await websocket.send(json.dumps(bet_msg))
+
+        # Get result
+        response = await websocket.recv()
+        result = json.loads(response)
+        print(f"Spinner result: {result}")
+
+        if "error" in result:
+            print(f"Error in spinner: {result['error']}")
+        else:
+            multiplier = result.get("multiplier", 0)
+            earnings = result.get("earnings", 0)
+            print(f"Multiplier: {multiplier}x")
+            print(f"Earnings: {earnings}")
+
+
+async def play_crash():
+    """Play the crash game and cash out after 2 seconds"""
+    # Get balance first
+    async with aiohttp.ClientSession() as session:
+        params = {"username": USERNAME, "password": PASSWORD}
+        async with session.get(f"{API_URL}/glares", params=params) as resp:
+            balance_data = await resp.json()
+            balance = balance_data.get("glares", 0)
+            print(f"Current balance before crash: {balance}")
+
+    # Connect to crash game
+    async with websockets.connect(WS_URL_CRASH) as websocket:
+        # Send authentication
+        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        await websocket.send(json.dumps(auth_msg))
+
+        # Receive welcome message
+        welcome = await websocket.recv()
+        data = json.loads(welcome)
+        print(f"Crash game connection: {data}")
+
+        # Wait 1 second
+        await asyncio.sleep(1)
+
+        # Place bet (half of balance)
+        bet_amount = max(int(balance / 2), 1)  # At least 1
+        bet_msg = {"bet": bet_amount}
+        print(f"Placing bet of {bet_amount} on crash game...")
+        await websocket.send(json.dumps(bet_msg))
+
+        # Set up a task to cash out after 2 seconds
+        async def cashout_after_delay():
+            await asyncio.sleep(2)
+            print("Cashing out after 2 seconds...")
+            await websocket.send(json.dumps({"action": "cashout"}))
+
+        cashout_task = asyncio.create_task(cashout_after_delay())
+
+        # Listen for messages
+        last_multiplier = 1.0
+        try:
+            while True:
+                response = await websocket.recv()
+                data = json.loads(response)
+
+                # Track multipliers
+                if "multiplier" in data:
+                    last_multiplier = data["multiplier"]
+                    print(f"Current multiplier: {last_multiplier}x", end="\r")
+
+                # Check for crash
+                if "crash" in data:
+                    print(f"\nGame crashed at {data['crash']}x!")
+                    break
+
+                # Check for cash out
+                if "cashed_out" in data:
+                    print(f"\nCashed out at {data['cashed_out']}x!")
+
+                # Check for final message
+                if "message" in data and "earnings" in data:
+                    print(f"Result: {data['message']}")
+                    print(f"Earnings: {data['earnings']}")
+                    break
+        except Exception as e:
+            print(f"Error in crash game: {e}")
+        finally:
+            if not cashout_task.done():
+                cashout_task.cancel()
+
+
+async def play_mines():
+    """Play the mines game with random placements and cash out after 5 reveals"""
+    # Get balance first
+    async with aiohttp.ClientSession() as session:
+        params = {"username": USERNAME, "password": PASSWORD}
+        async with session.get(f"{API_URL}/glares", params=params) as resp:
+            balance_data = await resp.json()
+            balance = balance_data.get("glares", 0)
+            print(f"Current balance before mines: {balance}")
+
+    # Connect to mines game
+    async with websockets.connect(WS_URL_MINES) as websocket:
+        # Send authentication
+        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        await websocket.send(json.dumps(auth_msg))
+
+        # Receive welcome message
+        welcome = await websocket.recv()
+        data = json.loads(welcome)
+        print(f"Mines game connection: {data}")
+
+        # Wait 1 second
+        await asyncio.sleep(1)
+
+        # Place bet (half of balance)
+        bet_amount = max(int(balance / 2), 1)  # At least 1
+        mines_count = 3  # Using 5 mines (medium difficulty)
+        bet_msg = {"bet": bet_amount, "mines": mines_count}
+        print(f"Placing bet of {bet_amount} on mines game with {mines_count} mines...")
+        await websocket.send(json.dumps(bet_msg))
+
+        # Keep track of revealed positions
+        revealed_positions = set()
+        available_positions = set(range(25))
+        num_reveals = 0
+        max_reveals = 5  # Cash out after 5 reveals
+
+        try:
+            while True:
+                # Choose a random position that hasn't been revealed yet
+                available = list(available_positions - revealed_positions)
+                if not available or num_reveals >= max_reveals:
+                    # Cash out after revealing max_reveals positions
+                    print(f"Cashing out after {num_reveals} reveals...")
+                    await websocket.send(json.dumps({"action": "cashout"}))
+                    break
+
+                position = random.choice(available)
+                print(f"Revealing position {position}...")
+                await websocket.send(
+                    json.dumps({"action": "reveal", "position": position})
+                )
+
+                # Get result
+                response = await websocket.recv()
+                data = json.loads(response)
+
+                if "error" in data:
+                    print(f"Error in mines game: {data['error']}")
+                    break
+
+                if "multiplier" in data and "revealed" in data:
+                    revealed_positions = set(data["revealed"])
+                    multiplier = data["multiplier"]
+                    print(f"Current multiplier: {multiplier}x")
+                    num_reveals += 1
+                    continue
+
+                # If we get here with other data, the game might be over
+                if "multiplier" in data and "earnings" in data:
+                    print(f"Game finished with multiplier: {data['multiplier']}x")
+                    print(f"Earnings: {data['earnings']}")
+                    if "safe_positions" in data:
+                        print(f"Safe positions were: {data['safe_positions']}")
+                    break
+
+        except Exception as e:
+            print(f"Error in mines game: {e}")
+
+
+async def play_tower():
+    """Play the tower game with random tile selections and cash out after a random number of levels"""
+    # Get balance first
+    async with aiohttp.ClientSession() as session:
+        params = {"username": USERNAME, "password": PASSWORD}
+        async with session.get(f"{API_URL}/glares", params=params) as resp:
+            balance_data = await resp.json()
+            balance = balance_data.get("glares", 0)
+            print(f"Current balance before tower: {balance}")
+
+    # Connect to tower game
+    async with websockets.connect(WS_URL_TOWER) as websocket:
+        # Send authentication
+        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        await websocket.send(json.dumps(auth_msg))
+
+        # Receive welcome message
+        welcome = await websocket.recv()
+        data = json.loads(welcome)
+        print(f"Tower game connection: {data}")
+
+        # Wait 1 second
+        await asyncio.sleep(1)
+
+        # Place bet (half of balance)
+        bet_amount = max(int(balance / 2), 1)  # At least 1
+        bet_msg = {"bet": bet_amount}
+        print(f"Placing bet of {bet_amount} on tower game...")
+        await websocket.send(json.dumps(bet_msg))
+
+        # Choose a random number of levels to attempt (1-8)
+        target_levels = random.randint(1, 8)
+        print(f"Will attempt {target_levels} levels before cashing out")
+
+        current_level = 0
+
+        try:
+            while True:
+                # Check if we've reached our target number of levels
+                if current_level >= target_levels:
+                    print(f"Reached target of {target_levels} levels. Cashing out...")
+                    await websocket.send(json.dumps({"action": "cashout"}))
+                    break
+
+                # Choose a random position (0-3) for the next level
+                position = random.randint(0, 3)
+                print(f"Selecting position {position} for level {current_level + 1}...")
+                await websocket.send(
+                    json.dumps({"action": "reveal", "position": position})
+                )
+
+                # Get result
+                response = await websocket.recv()
+                data = json.loads(response)
+
+                if "error" in data:
+                    print(f"Error in tower game: {data['error']}")
+                    break
+
+                if "level" in data and "multiplier" in data:
+                    current_level = data["level"]
+                    multiplier = data["multiplier"]
+                    print(
+                        f"Advanced to level {current_level} with multiplier: {multiplier}x"
+                    )
+                    continue
+
+                # If we get here with other data, the game might be over
+                if "multiplier" in data and "earnings" in data:
+                    print(f"Game finished with multiplier: {data['multiplier']}x")
+                    print(f"Earnings: {data['earnings']}")
+                    if "safe_positions" in data:
+                        print(f"Safe positions were: {data['safe_positions']}")
+                    break
+
+        except Exception as e:
+            print(f"Error in tower game: {e}")
+
+
+async def main():
+    await register_user()
+    await play_roulette()
+    # Play spinner all-in
+    # await play_spinner()
+    # Play crash game with cashout after 2 seconds
+    await play_crash()
+    # Play mines game with random placements
+    await play_mines()
+    # Play tower game with random levels
+    await play_tower()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())