def prepareGame(self): if self.camera: # Disable Mouse Control for camera self.disableMouse() self.camera.setPos(0, 0, 500) self.camera.lookAt(0, 0, 0) self.gameData = GameData(True) # game data self.broadcastData(('gamedata', self.gameData.packageData())) self.broadcastData(('state', 'preround')) if self.online: self.client.sendData(('state', 'preround')) print "Preparing Game" self.gameTime = 0 self.tick = 0 usersData = [] for user in self.users: usersData.append(user.gameData) self.game = Game(self, usersData, self.gameData) self.taskMgr.doMethodLater(0.5, self.roundReadyLoop, 'Game Loop') print "Round ready State"
def main(*flags): """Main game loop and event handling.""" # Initialization pygame.init() #Put window in center of screen os.environ ['SDL_VIDEO_WINDOW_POS'] = 'center' screen = pygame.display.set_mode(SCREEN_SIZE, pygame.FULLSCREEN if FULLSCREEN else 0) pygame.display.set_caption('Jeopardy!') # Declarations gameData = GameData() gs = JeopGameState() uicontroller = Controller(screen, gameData, FPS_LIMIT) clock = pygame.time.Clock() # Intro sequence (control passed completely to functions) if SKIP_INTRO_FLAG not in flags: pygame.mouse.set_visible(0) do_intro(screen, clock, uicontroller.audioplayer) do_scroll(screen, clock, gameData.categories) pygame.mouse.set_visible(1) # Prep for primary loop pygame.event.set_allowed(None) pygame.event.set_allowed(EVENTS_ALLOWED) uicontroller.draw(screen) # Primary loop while not gs.state == gs.GAME_END: # Events handle_events(gs, gameData, uicontroller) handle_buzzers(gs, gameData) if gs.state == gs.QUIT: pygame.quit() sys.exit() # Update gameData.update(gs) uicontroller.update(gs, gameData) gs.transition_state_immediate_linear(gameData) transition_state_branching(gs, gameData, uicontroller) # Draw uicontroller.draw(screen) # Cleanup pygame.event.pump() clock.tick_busy_loop(FPS_LIMIT) # Post game: Congratulations screen and credits pygame.mouse.set_visible(0) do_congrats(screen, clock, gameData.winners, uicontroller.audioplayer) do_credits(screen, clock, uicontroller.audioplayer, FPS_LIMIT)
def main(*flags): """Main game loop and event handling.""" # Initialization pygame.init() #Put window in center of screen os.environ['SDL_VIDEO_WINDOW_POS'] = 'center' screen = pygame.display.set_mode(SCREEN_SIZE, pygame.FULLSCREEN if FULLSCREEN else 0) pygame.display.set_caption('Jeopardy!') # Declarations gameData = GameData() gs = JeopGameState() uicontroller = Controller(screen, gameData, FPS_LIMIT) clock = pygame.time.Clock() # Intro sequence (control passed completely to functions) if SKIP_INTRO_FLAG not in flags: pygame.mouse.set_visible(0) do_intro(screen, clock, uicontroller.audioplayer) do_scroll(screen, clock, gameData.categories) pygame.mouse.set_visible(1) # Prep for primary loop pygame.event.set_allowed(None) pygame.event.set_allowed(EVENTS_ALLOWED) uicontroller.draw(screen) # Primary loop while not gs.state == gs.GAME_END: # Events handle_events(gs, gameData, uicontroller) handle_buzzers(gs, gameData) if gs.state == gs.QUIT: pygame.quit() sys.exit() # Update gameData.update(gs) uicontroller.update(gs, gameData) gs.transition_state_immediate_linear(gameData) transition_state_branching(gs, gameData, uicontroller) # Draw uicontroller.draw(screen) # Cleanup pygame.event.pump() clock.tick_busy_loop(FPS_LIMIT) # Post game: Congratulations screen and credits pygame.mouse.set_visible(0) do_congrats(screen, clock, gameData.winners, uicontroller.audioplayer) do_credits(screen, clock, uicontroller.audioplayer, FPS_LIMIT)
def main(debug, hostname, port, name): if debug: logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.DEBUG) else: logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO) # Connect to game server GameServer = ServerComms(hostname, port) # Spawn our tank logging.info("Creating tank with name '{}'".format(name)) GameServer.sendMessage(ServerMessageTypes.CREATETANK, {'Name': name}) # static reference to game, easier for other files to use it game.data = GameData(GameServer, name) game.data.game_server.sendMessage(ServerMessageTypes.TOGGLEFORWARD) # state.game_server.sendMessage(ServerMessageTypes.MOVEFORWARDDISTANCE, {"Amount": 10}) behavior_tree: BehaviorTree = behavior_tree_factory.get_tree() while True: messagePayload = GameServer.readMessage() game.data.update(messagePayload) behavior_tree.run()
def __init__(self, showbase): self.showbase = showbase self.ready = False self.background = DirectFrame( frameSize=(-1, 1, -1, 1), frameTexture='media/gui/mainmenu/menu.png', parent=self.showbase.render2d, ) self.title = OnscreenText(text='Lobby!', fg=(1, 1, 1, 1), parent=self.background, pos=(-0.6, 0.1), scale=0.06) self.buttons = [] controlButtons = Vec3(-0.60, 0, -0.79) # Toggle ready p = controlButtons + Vec3(-0.25, 0, 0) self.toggleReadyButton = DirectButton( text='Ready/Unready', pos=p, scale=0.048, relief=DGG.GROOVE, command=self.toggleReady, ) self.buttons.append(self.toggleReadyButton) # Disconnect p = controlButtons + Vec3(0.0, 0.0, 0.0) self.disconnectButton = DirectButton( text='Disconnect', pos=p, scale=0.048, relief=DGG.GROOVE, command=self.disconnect, ) self.buttons.append(self.disconnectButton) # Send message p = controlButtons + Vec3(0.25, 0.0, 0.0) self.sendMessageButton = DirectButton( text='Send Message', pos=p, scale=0.048, relief=DGG.GROOVE, command=self.sendMessage, extraArgs=[''], ) self.buttons.append(self.sendMessageButton) # Message input self.message = DirectEntry( command=self.sendMessage, focusInCommand=self.clearText, frameSize=(-3, 3, -.5, 1), initialText='', parent=self.buttons[2], pos=(0, -0.6, -1.5), text_align=TextNode.ACenter, ) self.showbase.gameData = GameData() self.showbase.users = [] self.hide()
class Server(ShowBase): def __init__(self): ShowBase.__init__(self) # Server Networking handling stuff self.compress = False self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.tempConnections = [] self.unauthenticatedUsers = [] self.users = [] self.passedData = [] self.connect(9099, 1000) self.startPolling() self.attemptAuthentication() self.taskMgr.doMethodLater(0.5, self.lobbyLoop, 'Lobby Loop') def connect(self, port, backlog = 1000): # Bind to our socket tcpSocket = self.cManager.openTCPServerRendezvous(port, backlog) self.cListener.addConnection(tcpSocket) def startPolling(self): self.taskMgr.add(self.tskListenerPolling, "serverListenTask", -40) self.taskMgr.add(self.tskDisconnectPolling, "serverDisconnectTask", -39) def tskListenerPolling(self, task): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.cListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() newConnection.setNoDelay(True) self.tempConnections.append(newConnection) # Remember connection self.cReader.addConnection(newConnection) # Begin reading connection return Task.cont def tskDisconnectPolling(self, task): while self.cManager.resetConnectionAvailable() == True: connPointer = PointerToConnection() self.cManager.getResetConnection(connPointer) connection = connPointer.p() # Remove the connection we just found to be "reset" or "disconnected" self.cReader.removeConnection(connection) # remove from our activeConnections list if connection in self.tempConnections: self.tempConnections.remove(connection) for user in self.unauthenticatedUsers: if connection == user.connection: self.unauthenticatedUsers.remove(user) for user in self.users: if connection == user.connection: user.connection = None self.passData(('disconnect', user.name), None) return Task.cont def broadcastData(self, data): # Broadcast data out to all users for user in self.users: if user.connection: self.sendData(data, user.connection) def processData(self, netDatagram): myIterator = PyDatagramIterator(netDatagram) return self.decode(myIterator.getString()) def getUsers(self): # return a list of all users return self.users def encode(self, data, compress = False): # encode(and possibly compress) the data with rencode return rencode.dumps(data, compress) def decode(self, data): # decode(and possibly decompress) the data with rencode return rencode.loads(data) def sendData(self, data, con): myPyDatagram = PyDatagram() myPyDatagram.addString(self.encode(data, self.compress)) self.cWriter.send(myPyDatagram, con) def passData(self, data, connection): self.passedData.append((data, connection)) def getData(self): data = [] for passed in self.passedData: data.append(passed) self.passedData.remove(passed) while self.cReader.dataAvailable(): datagram = NetDatagram() if self.cReader.getData(datagram): if datagram.getConnection() in self.tempConnections: self.processTempConnection(datagram) continue for authed in self.users: if datagram.getConnection() == authed.connection: data.append((self.processData(datagram), datagram.getConnection())) return data def processTempConnection(self, datagram): connection = datagram.getConnection() package = self.processData(datagram) if len(package) == 2: if package[0] == 'username': print 'attempting to authenticate', package[1] self.tempConnections.remove(connection) if not self.online: user = User(package[1], connection) # confirm authorization self.sendData(('auth', user.name), user.connection) self.updateClient(user) self.users.append(user) else: self.client.sendData(('auth', package[1])) self.unauthenticatedUsers.append(User(package[1], connection)) def attemptAuthentication(self): config = ConfigParser.RawConfigParser() config.read('server.cfg') self.SERVER_NAME = config.get('SERVER DETAILS', 'serverName') config = ConfigParser.RawConfigParser() config.read('master.cfg') self.LOGIN_IP = config.get('MASTER SERVER CONNECTION', 'masterIp') self.LOGIN_PORT = config.getint('MASTER SERVER CONNECTION', 'masterPort') # Client for connecting to main server for showing exists and receiving clients self.client = Client(self, self.LOGIN_IP, self.LOGIN_PORT, compress = True) if self.client.getConnected(): self.client.sendData(('server', self.SERVER_NAME)) self.taskMgr.add(self.clientValidator, 'Client Validator') self.client.sendData(('state', 'lobby')) self.online = True else: # client not connected to login/auth server print 'Could not connect to Authentication Server.' print 'Server is not in online mode. No Authentication will happen for clients.' print 'Restart Server to attempt to connect to Authentication Server.' self.client = None self.online = False def clientValidator(self, task): temp = self.client.getData() for package in temp: if len(package) == 2: if package[0] == 'auth': print 'User authenticated: ', package[1] for user in self.unauthenticatedUsers: if user.name == package[1]: # confirm authorization self.sendData(('auth', user.name), user.connection) # send all required data to user self.updateClient(user) # all authenticated users self.users.append(user) self.unauthenticatedUsers.remove(user) print 'confirmation sent to ', package[1] break elif package[0] == 'fail': print 'User failed authentication: ', package[1] for user in self.unauthenticatedUsers: if user.name == package[1]: self.sendData(('fail', user.name), user.connection) self.unauthenticatedUsers.remove(user) break return task.again def updateClient(self, user): for existing in self.users: if existing.name != user.name: self.sendData(('client', existing.name), user.connection) self.sendData(('ready', (existing.name, existing.ready)), user.connection) if existing.connection: self.sendData(('client', user.name), existing.connection) self.sendData(('client', user.name), user.connection) def lobbyLoop(self, task): temp = self.getData() for package in temp: if len(package) == 2: print "Received: ", str(package) packet = package[0] connection = package[1] if len(packet) == 2: # check to make sure connection has username for user in self.users: if user.connection == connection: # if chat packet if packet[0] == 'chat': print 'Chat: ', packet[1] # Broadcast data to all clients ("username: message") self.broadcastData(('chat', (user.name, packet[1]))) # else if ready packet elif packet[0] == 'ready': print user.name, ' changed readyness!' user.ready = packet[1] self.broadcastData(('ready', (user.name, user.ready))) # else if disconnect packet elif packet[0] == 'disconnect': print user.name, ' is disconnecting!' self.users.remove(user) self.broadcastData(('disconnect', user.name)) # break out of for loop break # if all players are ready and there is X of them gameReady = True # if there is any clients connected if self.getUsers() == []: gameReady = False for user in self.users: if not user.ready: gameReady = False if gameReady: self.prepareGame() return task.done return task.again def prepareGame(self): if self.camera: # Disable Mouse Control for camera self.disableMouse() self.camera.setPos(0, 0, 500) self.camera.lookAt(0, 0, 0) self.gameData = GameData(True) # game data self.broadcastData(('gamedata', self.gameData.packageData())) self.broadcastData(('state', 'preround')) if self.online: self.client.sendData(('state', 'preround')) print "Preparing Game" self.gameTime = 0 self.tick = 0 usersData = [] for user in self.users: usersData.append(user.gameData) self.game = Game(self, usersData, self.gameData) self.taskMgr.doMethodLater(0.5, self.roundReadyLoop, 'Game Loop') print "Round ready State" def roundReadyLoop(self, task): temp = self.getData() for package in temp: if len(package) == 2: print "Received: ", str(package) if len(package[0]) == 2: for user in self.users: if user.connection == package[1]: if package[0][0] == 'round': if package[0][1] == 'sync': user.sync = True # if all players are ready and there is X of them roundReady = True # if there is any clients connected for user in self.users: if user.sync == False: roundReady = False if roundReady: self.taskMgr.doMethodLater(2.5, self.gameLoop, 'Game Loop') print "Game State" return task.done return task.again def gameLoop(self, task): # process incoming packages temp = self.getData() for package in temp: if len(package) == 2: # check to make sure connection has username for user in self.users: if user.connection == package[1]: user.gameData.processUpdatePacket(package[0]) # get frame delta time dt = self.taskMgr.globalClock.getDt() self.gameTime += dt # if time is less than 3 secs (countdown for determining pings of clients?) # tick out for clients while self.gameTime > gameTick: # update all clients with new info before saying tick for user in self.users: updates = user.gameData.makeUpdatePackets() for packet in updates: self.broadcastData((user.name, packet)) self.broadcastData(('tick', self.tick)) self.gameTime -= gameTick self.tick += 1 # run simulation if not self.game.runTick(gameTick): print 'Game Over' # send to all players that game is over (they know already but whatever) # and send final game data/scores/etc for user in self.users: user.ready = False self.taskMgr.doMethodLater(0.5, self.lobbyLoop, 'Lobby Loop') return task.done return task.cont
def load_realtime_data(self): sharedData = {} self.parser = self.bot.set_up_parser(sharedData, self.do_turn) self.data = GameData(sharedData) self.data.reset()
class Brain: """The brain: parses lines, combines data classes to make decisions""" def __init__(self, bot): with Timer() as t: self.bot = bot self.load_realtime_data() self.load_precalc_data() self.iterations = 400 self.bot.log("Brain started up in {t} secs".format(t=t.secs)) def load_realtime_data(self): sharedData = {} self.parser = self.bot.set_up_parser(sharedData, self.do_turn) self.data = GameData(sharedData) self.data.reset() def load_precalc_data(self): """Loads pre-computed hand data""" infile = os.path.join('data', 'preflop_wins_5000.pickle') try: in_stream = open(infile, 'r') try: self.preflop_equity = pickle.load(in_stream) self.bot.log("Loaded preflop equity file") finally: in_stream.close() except IOError: self.bot.log("IO error loading {f}".format(f=infile)) def parse_line(self, line): """Feeds a line to the parsers""" success = self.parser.handle_line(line) if success: self.data.update() else: self.bot.log("didn't handle line: " + line + "\n") def pot_odds(self): """Return the pot odds, or how much we need to gain to call""" to_call = self.data.sidepot pot_total = to_call + self.data.pot return MathUtils.percentage(to_call, pot_total) def do_turn(self, timeLeft_ms): """Wraps internal __do_turn so we can time how long each turn takes""" with Timer() as t: self.__do_turn(timeLeft_ms) self.bot.log("Finished turn in {t}s ({i} sims), had {l}s remaining" .format(t=t.secs, i=self.iterations, l=(timeLeft_ms/1000 - t.secs))) def __do_turn(self, timeLeft_ms): """Callback for when the brain has to make a decision""" if not self.data.hand: self.bot.log("No hand, killing ourselves. Data={d}" .format(d=self.data)) self.bot.fold() return hand = self.data.hand pot_odds = self.pot_odds() equity = 0 if not self.data.table_cards: equity = self.preflop_equity[repr(hand)] else: simulator = HandSimulator(hand, self.data.table_cards) best_hand, score = simulator.best_hand() self.bot.log("best 5: {b} score: {s}" .format(b=str(best_hand), s=score)) equity = simulator.simulate(self.iterations) self.bot.log("{h}, equity: {e}%, pot odds: {p}%" .format(h=hand, e=equity, p=pot_odds)) self.pick_action(equity, pot_odds) def pick_action(self, equity, pot_odds): """Look at our expected return and do something. Will be a semi-random mix of betting, folding, calling""" to_call = self.data.sidepot # action to us: check or bet if to_call == 0: if equity > 0.7 or self.r_test(0.03): self.bot.bet(self.big_raise()) elif equity > 0.5 or self.r_test(0.05): self.bot.minimum_bet() else: # equity <= 0.3: self.bot.check() # use pot odds to call/bet/fold else: return_ratio = equity / pot_odds if return_ratio > 1.5 or self.r_test(0.02): self.bot.bet(self.big_raise()) elif return_ratio > 1: self.bot.call(to_call) else: self.bot.fold() def big_raise(self): """Returns a big raise, 30-50% of the pot""" pot = self.data.pot bet_raise = random.uniform(0.3, 0.5) * pot self.bot.log("big raise of {r}".format(r=bet_raise)) return bet_raise def minimum_bet(self): """Returns a minimum bet, 2.5-4 BB""" bet = self.data.big_blind * random.uniform(2, 4) self.bot.log("min bet of {b}".format(b=bet)) return bet def r_test(self, fraction): """Given a number [0,1], randomly return true / false s.t. r_test(0.5) is true ~50% of the time""" passed = random.uniform(0, 1) < fraction if passed: self.bot.log("r_test() passed for %{f}".format(f=fraction)) return passed
def main(): parse_args() # Sets CONFIG options. # Must be called before UIManager instantiated. pygame.init() pygame.display.set_caption('Flippyflap Wivs') environ['SDL_VIDEO_WINDOW_POS'] = 'center' # Load high score pd = PersistentData(DATA_PATH) if path.exists(DATA_PATH): pd.load() else: pd.high_score = 0 clock = pygame.time.Clock() dt = 1 gdt = 60 / CONFIG.FPS_LIMIT gs = GameState() gd = GameData(pd.high_score) uim = UIManager(gd.n_columns, gdt*gd.scroll_speed) end = False # Prep for game loop pygame.mouse.set_visible(0) pygame.event.set_allowed(None) pygame.event.set_allowed( (pygame.KEYDOWN, pygame.QUIT, pygame.MOUSEBUTTONDOWN) ) # Game loop while not end: # Transition state gs.transition_state() # Handle Events for event in pygame.event.get(): if event.type == pygame.QUIT: end = True elif event.type == pygame.KEYDOWN: handle_event_keydown(gs, event) elif event.type == pygame.MOUSEBUTTONDOWN: handle_event_mousebuttondown(gs, event) if gs.state == gs.QUIT: end = True if gs.state != gs.PAUSE: # Update gd.update(gs, gdt) uim.update(gs, gd, dt) gd.postupdate(gs, gdt) # Draw uim.draw() # Cleanup clock.tick(CONFIG.FPS_LIMIT) fps = clock.get_fps() gdt = 60 / (fps if fps > 15 else CONFIG.FPS_LIMIT) dt = fps / CONFIG.FPS_LIMIT pygame.event.pump() # Save high score pd.high_score = gd.high_score pd.save() pygame.quit()
class Brain(BetSizeCalculator, Fear): """The brain: parses lines, combines data classes to make decisions""" def __init__(self, bot): with Timer() as t: self.bot = bot self.load_realtime_data() self.load_precalc_data() self.iterations = 2000 self.bot.log("Brain started up in {t} secs".format(t=t.secs)) def load_realtime_data(self): sharedData = {} self.parser = self.bot.set_up_parser(sharedData, self.do_turn) self.data = GameData(sharedData) self.data.reset() def load_precalc_data(self): """Loads pre-computed hand data""" preflop = preflop_equity.PreflopEquity(log_func=self.bot.log) self.preflop_equity = preflop.data def parse_line(self, line): """Feeds a line to the parsers""" success = self.parser.handle_line(line) if success: self.data.update() else: self.bot.log("didn't handle line: '{}'".format(line)) def do_turn(self, bot, total_time_left_ms): """Wraps internal __do_turn so we can time how long each turn takes""" time_left = min(total_time_left_ms, self.data.time_per_move) if not bot or bot != self.data.me: return with Timer() as t: self.__do_turn(time_left) if not self.data.table_cards: turn_type = "preflop" else: turn_type = "{} sims".format(self.iterations) left = (time_left / 1000) - t.secs self.bot.log("Finished turn in {t}s ({s}), had {l}s remaining" .format(t=t.secs, s=turn_type, l=left)) def __do_turn(self, time_left_ms): """Callback for when the brain has to make a decision""" if not self.data.hand: self.bot.log("No hand, killing ourselves. Data={d}" .format(d=self.data)) self.bot.fold() return hand = self.data.hand stack = self.our_stack() to_call = self.to_call(silent=False) pot_odds = self.pot_odds() equity = 0 self.update_fear(to_call) preflop_fear = self.data.preflop_fear hand_fear = self.data.hand_fear # preflop, no big raises. safe to use our precalculated win % if not self.data.table_cards and preflop_fear == -1: equity = self.preflop_equity[hand.simple()] source = "preflop" else: simulator = HandSimulator(hand, self.data.table_cards, self.preflop_equity) best_hand, score = simulator.best_hand() equity = self.__run_simulator(simulator, time_left_ms, preflop_fear, hand_fear) source = "sim" self.bot.log(" hand: {h}, table: {t}" .format(h=hand, t=[str(t) for t in self.data.table_cards])) if self.data.table_cards: self.bot.log(" best 5: {b} score: {s}" .format(b=[str(c) for c in best_hand], s=str(score))) self.bot.log(" win: {e:.2f}% ({s}), pot odds: {p:.2f}%, stack={m}" .format(e=equity, s=source, p=pot_odds, m=stack)) self.bot.log(" pre-fear={pf}, hand-fear=({hf})" .format(pf=preflop_fear, hf=hand_fear)) self.pick_action(equity, to_call, pot_odds) def __run_simulator(self, simulator, time_left_ms, hand_filter, hand_fear): results = [] step_size = 100 start_time = time.clock() * 1000 end_time = start_time + time_left_ms - 50 for i in range(0, self.iterations, step_size): now = time.clock() * 1000 if now >= end_time: self.bot.log(" stopping simulation after {} runs".format(i)) break equity = simulator.simulate(step_size, hand_filter, hand_fear) results.append(equity) return sum(results) / len(results) def pick_action(self, equity, to_call, pot_odds): """Look at our expected return and do something. Will be a semi-random mix of betting, folding, calling""" # action to us: check or bet if to_call == 0: # lock hands - 1/3 of the time make a small bet instead of a big one if equity > 90 and self.r_test(0.33, 'lock_trap'): self.make_bet(self.minimum_bet("trap1")) elif equity > 65 or (equity > 40 and self.r_test(0.03, 'c1')): self.make_bet(self.big_raise("R1")) elif equity > 55 or self.r_test(0.02, 'c2'): self.make_bet(self.minimum_bet("R2")) else: self.bot.check() # TODO: combine these and make them aware of button # use pot odds to call/bet/fold else: return_ratio = equity / pot_odds self.bot.log(" return ratio={:.3f}".format(return_ratio)) if equity > 70 or (equity > 40 and self.r_test(0.03, 'po1')): self.make_bet(self.big_raise("R3")) elif to_call < self.data.big_blind and \ (equity > 55 or self.r_test(0.03, 'po2')): # small preflop raise from SB, get more money into the pot self.make_bet(self.minimum_bet("R4")) elif return_ratio > 1.25: self.bot.log(" return ratio > 1.25, calling {}".format(to_call)) self.bot.call(to_call) elif return_ratio > 1 \ and MathUtils.percentage(to_call, self.our_stack()) < 10: self.bot.log(" return ratio > 1 and bet is small, calling {}" .format(to_call)) self.bot.call(to_call) else: self.bot.fold() def make_bet(self, amount): """Make a bet, also update fear assumming the opponent will call.""" self.update_fear(amount) self.bot.bet(amount) def r_test(self, fraction, block=None): """Given a number [0,1], randomly return true / false s.t. r_test(0.5) is true ~50% of the time""" passed = random.uniform(0, 1) < fraction if passed: self.bot.log(" r_test({f}%) passed from {b}" .format(f=100*fraction, b=block)) return passed