1
def game_loop():
2
    """Background game loop"""
3
    round_number = 0
4
    random.seed(int(time.time()))
5
    mult_list = [generate_multiplier() for i in range(10000)]
6
    while True:
7
        # Start new round
8
        gs.max_multiplier = mult_list[round_number % 10000]
9
        round_number += 1
10
        gs.current_multiplier = 1.0
11
        gs.game_phase = 'betting'
12
        gs.round_start_time = time.time()

1
#!/usr/bin/env python3
2

3
import asyncio
4
import random
5
import time
6
import socketio
7
import functools
8
import concurrent.futures
9

10
URL       = "http://localhost:5000"
11
SIO_PATH  = "/socket.io"
12
HOUSE     = 0.01
13
OBS_N     = 10
14
SEARCH_H  = 12 * 3600  # +- 12 ore
15
EXEC      = concurrent.futures.ThreadPoolExecutor(max_workers=1)
16

17
def _mult(rng, house_edge=HOUSE):
18
    F = 1 - house_edge
19
    return (1 / rng.uniform(0.01, 1.0)) * F
20

21
def build_seq(seed, n=10_000):
22
    rng = random.Random(seed)
23
    return [_mult(rng) for _ in range(n)]
24

25
def brute_seed_sync(obs, start, end):
26
    for seed in range(start, end + 1):
27
        seq = build_seq(seed)
28
        for i in range(len(seq) - len(obs) + 1):
29
            if all(abs(seq[i+j] - obs[j]) < 0.01 for j in range(len(obs))):
30
                return seed, i
31
    raise RuntimeError("Seed non trovato")
32

33
async def main():
34
    sio         = socketio.AsyncClient()
35
    observed    = []
36
    brute_fut   = None
37
    seed        = offset = None
38
    sequence    = None
39
    idx         = 0
40
    has_bet     = False
41
    has_cashed  = False
42
    balance = None
43

44
    @sio.event
45
    async def connect():
46
        print(f"[+] connected – waiting {OBS_N} crash…")
47

48
    @sio.on("cashout_response")
49
    async def on_bet_response(data):
50
        nonlocal balance
51
        if data.get("success"):
52
            balance = data.get("balance")
53
            print(f"[+] Bet accepted. New balance: {balance}")
54
        else:
55
            print("[-] Bet failed.")
56

57
    @sio.on("game_state")
58
    async def on_state(d):
59
        nonlocal brute_fut, seed, offset, sequence, idx, has_bet, has_cashed, balance
60
        phase = d["phase"]
61

62
        if phase == "betting":
63
            if seed is not None and not has_bet:
64
                if balance is None:
65
                    balance = 10
66
                if sequence is not None:
67
                    print("[+] Current balance: ",balance)
68
                    next_crash = sequence[(idx - 1) % 10_000]
69
                    print(f"[+] Betting – predicted crash: {next_crash:.2f}")
70
                    await sio.emit("place_bet", {"amount": int(balance)})
71
                    has_bet = True
72

73
        elif phase == "game":
74
            if seed is not None and has_bet and not has_cashed:
75
                next_crash = sequence[(idx - 1) % 10_000]
76
                cashout_at = max(1.01, next_crash - 0.05)
77
                current_multiplier = float(d.get("multiplier", 1.0))
78

79
                if current_multiplier >= cashout_at:
80
                    print(f"[+] Cashing out at {current_multiplier:.2f} "
81
                          f"(before predicted crash {next_crash:.2f})")
82
                    await sio.emit("cashout")
83
                    has_cashed = True
84

85
        elif phase == "ended":
86
            crash = float(d["multiplier"])
87
            observed.append(crash)
88
            print(f"[+] crash #{len(observed)}: {crash:.2f}")
89

90
            if brute_fut is None and len(observed) >= OBS_N:
91
                now   = int(time.time())
92
                start = now - SEARCH_H
93
                print(f"[+] brute-force {start} → {now}… (in thread)")
94
                loop = asyncio.get_running_loop()
95
                brute_fut = loop.run_in_executor(
96
                    EXEC,
97
                    functools.partial(brute_seed_sync,
98
                                      obs=observed[:OBS_N],
99
                                      start=start,
100
                                      end=now)
101
                )
102

103
            if brute_fut is not None and brute_fut.done() and seed is None:
104
                seed, offset = brute_fut.result()
105
                sequence = build_seq(seed)
106
                idx = offset + len(observed)
107
                print("\n[+]  seed:", seed)
108
                print("[+]  start offset:", offset)
109
                print("[+]  current round:", idx % 10_000, "\n")
110

111
            if seed is not None:
112
                next_crash = sequence[idx % 10_000]
113
                print(f"[+]  Next expected crash: {next_crash:.2f}")
114
                idx += 1
115
            has_bet = False
116
            has_cashed = False
117

118

119
    @sio.on("error")
120
    async def on_error(msg):
121
        if "corn{" in msg:
122
            print("FLAG: ", msg["message"])
123
            exit(0)
124
        print("⚠️  server error:", msg)
125

126
    await sio.connect(URL, socketio_path=SIO_PATH, transports=["websocket"])
127
    await sio.wait()
128

129
if __name__ == "__main__":
130
    asyncio.run(main())