def __init__(self, price, kind_of_bet): Bet.__init__(self, price, kind_of_bet) bet_types = [ '', self.low_high, self.red_black, self.even_odd, self.dozen, self.column, self.single, self.split, self.street, self.square, self.neighbors_of_zero ] function = bet_types[self.type] function()
def test_place_bet(): wheel = create_wheel() table = Table(wheel) zerozero = Outcome("00", 35) zerozero_bet = Bet(900, zerozero) red_bet = Bet(60, Outcome("Red", 1)) table.place_bet(zerozero_bet) table.place_bet(red_bet) assert [x.bet_amount for x in table] == [900, 60] with pytest.raises(InvalidBet): table.place_bet(red_bet)
def __init__(self): # Initialisation des joueurs self.user = User([]) # Appel de la méthode pour créer les joueurs self.user.generate_player() # Appel du nom des joueurs self.players = self.user.players # Initialisation des paris self.bet = Bet(1000) # Initialisation du paquet self.deck = Deck() # Appel de la méthode pour mélanger le paquet self.deck.shuffle()
class BetTestCase(unittest.TestCase): def setUp(self): self.outcome_five = Outcome("00-0-1-2-3", RouletteGame.FiveBet) self.outcome_zero = Outcome("Number 0", RouletteGame.StraightBet) self.bet_five = Bet(1000, self.outcome_five) self.bet_zero = Bet(1000, self.outcome_zero) def test_win_amount(self): self.assertEqual(self.bet_five.win_amount(), 1000 + 1000 * 6) self.assertEqual(self.bet_zero.win_amount(), 1000 + 1000 * 35) def test_lose_amount(self): self.assertEqual(self.bet_five.lose_amount(), 1000) self.assertEqual(self.bet_zero.lose_amount(), 1000)
def bet(self, player): super().bet(player) betTypes = ['', self.altoBaixo, self.vermelhoPreto, self.parImpar, self.duzia, self.coluna, self.single, self.split, self.street, self.square, self.neighborsOfZero] if self.betType == 0: player.bet = Bet(0, 0, '', '') return function = betTypes[self.betType] function() winningPrize = super().getWinningPrize() player.bet = Bet(self.betValue, self.betType, self.winningRange, winningPrize)
def scrape_match_bets(self, match): t = time.time() self.renderer.get(match.url) try: teams = match.title.raw_teams except AttributeError: teams = match.title.teams main_row = self.renderer.find_element_by_class_name('sub-row') main_odds = main_row.find_elements_by_class_name('selection-link') main_bet_titles = ['Result ' + team + ' To Win' for team in teams] if len(main_odds) == 3: main_bet_titles.insert(1, 'Result Draw') match.bets += [ Bet(main_bet_titles[i], main_odds[i].text, MarathonScraper._NAME, match.url) for i in range(len(teams)) ] try: element = self.renderer.wait.until( EC.presence_of_element_located( (By.CLASS_NAME, 'details-description'))) all_markets_button = element.find_element_by_tag_name('td') self.renderer.click(all_markets_button) except Exception: print(self._NAME, time.time() - t) return match self._parse_marketblocks(match.bets, match.url) print(self._NAME, time.time() - t) return match
def predictGame(team1, team2, spread): game = Game(team1, team2, spread=spread) os.remove('predictionGame.csv') header = "date,home_team,visitor_team,home_points,visitor_points,home_margin_of_victory,favorite,spread,total," \ "cover,over,team_points,team_total_yards,team_plays_offense,team_yds_per_play_offense,team_turnovers," \ "team_fumbles_lost,team_first_down,team_pass_cmp,team_pass_att,team_pass_yds,team_pass_td,team_pass_int," \ "team_pass_net_yds_per_att,team_pass_fd,team_rush_att,team_rush_yds,team_rush_td,team_rush_yds_per_att," \ "team_rush_fd,team_penalties,team_penalties_yds,team_pen_fd,team_drives,team_score_pct," \ "team_turnover_pct,team_start_avg,team_time_avg,team_plays_per_drive,team_yds_per_drive,team_points_avg," \ "opp_points,opp_total_yards,opp_plays_offense,opp_yds_per_play_offense,opp_turnovers,opp_fumbles_lost," \ "opp_first_down,opp_pass_cmp,opp_pass_att,opp_pass_yds,opp_pass_td,opp_pass_int," \ "opp_pass_net_yds_per_att,opp_pass_fd,opp_rush_att,opp_rush_yds,opp_rush_td,opp_rush_yds_per_att," \ "opp_rush_fd,opp_penalties,opp_penalties_yds,opp_pen_fd,opp_drives,opp_score_pct,opp_turnover_pct," \ "opp_start_avg,opp_time_avg,opp_plays_per_drive,opp_yds_per_drive,opp_points_avg" + '\n' with open('predictionGame.csv', 'a') as fd: fd.write(header) fd.write(game.getCSVString()) fd.write(game.getCSVString()) dataset = pd.read_csv('predictionGame.csv', delimiter=',') dataset = dataset.drop([ 'home_team', 'visitor_team', 'home_points', 'visitor_points', 'favorite', 'total', 'cover', 'home_margin_of_victory', 'over', 'date' ], axis=1) dataset = dataset.to_numpy() if dataset[0][0] == 'OTB': return "Game OTB" predictions = model.predict_proba(dataset) return Bet( ('%s %s %s \nPick: %s (%d' % (team1.name, spread, team2.name, team1.name if predictions[0][0] * 100 > 50 else team2.name, predictions[0][0] * 100 if predictions[0][0] * 100 > 50 else 100 - predictions[0][0] * 100) + "%)\n\n"))
def next_bet(self): """ Implements Player.next_bet. Bet on Black with the correct bet amount """ black = self.table.wheel.get_outcome("Black") return Bet(self.bet_amount, black)
def next_bet(self): """ Make only one bet: 10 on black, and place it on the table """ black = self.table.wheel.get_outcome("Black") return Bet(self.bet_amount, black)
def get_ml_bet(self, row, team, pinnacle): line_class = 'linesMl' if team == 'draw' else 'linesTotal' line = row.find_element_by_class_name(line_class) add_bet_line = line.get_attribute('onclick') if add_bet_line: bet_line = add_bet_line.split(',') odds = int(bet_line[5].replace("'", "")) pinnacle_odds = pinnacle.get_ml_odds( self.period, self.period_text, team, self.is_last_name(), ) if pinnacle_odds: bet = Bet( sport = self.sport, title = self.title, team = team, action_odds = odds, pinnacle_odds = pinnacle_odds, bet_type = 'ml', add_bet_line = add_bet_line, ) return bet
def get_ou_bet(self, row, team, pinnacle, home_or_away): line = row.find_element_by_class_name('linesMl') add_bet_line = line.get_attribute('onclick') if add_bet_line: bet_line = add_bet_line.split(',') bet_type = 'over' if bet_line[2].lower() == "'ov'" else 'under' line = float(bet_line[4].replace("'", "")) odds = int(bet_line[5].replace("'", "")) pinnacle_odds = pinnacle.get_ou_odds( self.period, self.period_text, self.get_total_type(), bet_type, line, home_or_away, self.ou_multiplier, ) if pinnacle_odds: bet = Bet( sport=self.sport, title=self.title, team=team, action_line=line, action_odds=odds, pinnacle_odds=pinnacle_odds, bet_type=bet_type, add_bet_line=add_bet_line, ) return bet
def get_user_bk_info(self): """Получает данные аккаунта пользователя""" self.browser.get(self.make_url('myaccount/myaccount.htm')) WebDriverWait(self.browser, self.timeout).until( EC.presence_of_element_located((By.CLASS_NAME, 'history-result'))) # Вытягиваем основной баланс total_summ_element = self.browser.find_element_by_css_selector( '[data-punter-balance-value]') total_summ = float( total_summ_element.get_attribute('data-punter-balance-value')) # Вытягиваем нерассчитанные ставки bets_summ_element = self.browser.find_element_by_xpath( '//*[contains(text(), "Нерассчитанные")]/ancestor::tr/*[contains(@class, "value")]' ) bets_summ = float(re.sub('[^.0-9]', '', bets_summ_element.text)) # Вытягиваем историю пари bets = [] history_results = self.browser.find_elements_by_class_name( 'history-result-main') for history_result in history_results: # Выплата result = history_result.find_element_by_class_name( 'result').text.strip().replace('₽ ', '') try: result = float(result) except: result = None # Статус ставки open_bet_element = history_result.find_element_by_class_name( 'open-bet') open_bet = -1 try: open_bet_element.find_element_by_xpath( '*[contains(@src, "win-icon")]') open_bet = 1 except: try: open_bet_element.find_element_by_xpath( '*[contains(@src, "lose-icon")]') open_bet = 0 except: pass # Добавляем запись истории bets.append( Bet( history_result.find_element_by_class_name( 'bet-number').text.strip(), history_result.find_element_by_class_name( 'date').text.strip(), history_result.find_element_by_class_name('bet-title'). find_elements_by_tag_name('span')[1].text.strip(), float( re.sub( '[^.0-9]', '', history_result.find_element_by_class_name( 'total-stake').text)), result, float( history_result.find_element_by_class_name( 'coefficient').text.strip()), open_bet)) return UserBkInfo(total_summ, bets_summ, bets)
def _get_bets_from_url(self, match_url): self.renderer(match_url) event = self.renderer.find_element_by_class_name( 'category-content').find_element_by_class_name('bg') # match = self._get_bets(event) bets = [] match = self._get_match_basic_data(event) teams = match.title.teams main_odds = event.find_elements_by_class_name('selection-link') if len(main_odds) == 3: teams.insert(1, 'draw') bets += [ Bet(teams[i] + ' will win', main_odds[i].text, MarathonScraper._NAME, match.url) for i in range(len(teams)) ] try: element = self.renderer.wait.until( EC.presence_of_element_located( (By.CLASS_NAME, 'details-description'))) all_markets_button = element.find_element_by_tag_name('td') self.renderer.click(all_markets_button) except Exception: return match time.sleep(0.5) try: self._parse_marketblocks(bets, match.url) except Exception: return match match.bets = bets time.sleep(0.2) return match
def get_handicap_bet(self, row, team, pinnacle, home_or_away): line = row.find_element_by_class_name('linesSpread') add_bet_line = line.get_attribute('onclick') if add_bet_line: bet_line = add_bet_line.split(',') line = float(bet_line[4].replace("'", "").replace("PK", "0")) odds = int(bet_line[5].replace("'", "")) pinnacle_odds = pinnacle.get_handicap_odds( self.period, self.period_text, home_or_away, line, self.handicap_multiplier, ) if pinnacle_odds: bet = Bet( sport=self.sport, title=self.title, team=team, action_line=line, action_odds=odds, pinnacle_odds=pinnacle_odds, bet_type='handicap', add_bet_line=add_bet_line, ) return bet
def next_bet(self): """ Make a random bet by choosing a random outcome from all the possible outcomes """ outcome = self.rng.choice(self.outcomes_pool) bet = Bet(self.bet_amount, outcome) return bet
def create_bets_with_outcome_lowest_quote(self): self.bets = [] for match in self.matches: outcome = match.get_outcome_with_lowest_quote() self.bets.append(Bet(match, outcome)) return self.bets
class TestBet(unittest.TestCase): bet1 = Bet(10, TestOutcome.oc1) bet2 = Bet(25, TestOutcome.oc2) bet3 = Bet(10, TestOutcome.oc4) bet4 = Bet(1, TestOutcome.oc1) def test_bet_win_amount(self): self.assertEqual(self.bet1.winAmount(), 360, "Should be 360.") def test_bet_lose_amount(self): self.assertEqual(self.bet1.loseAmount(), 10, "Should be 10.") def test_str(self): self.assertEqual(self.bet1.__str__(), "10 on 0", "Should be 10 on 0") def test_repr(self): self.assertEqual(self.bet1.__repr__(), "Bet(10, Outcome('0', 35))", "Should be Bet(10, Outcome(0, 35))")
def default_no_compensation(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Same as default, but it does not compensate a lower probability. ''' firstRate = rates[0] firstWeight = weights[0] betAmmount = int(balance * utils.PERCENAGE_FOR_BET) return Bet(0, betAmmount)
def test_state(self): noWins = Player1326NoWins(self.player) print(noWins.currentBet()) self.assertEqual(noWins.currentBet().__repr__(), Bet(1, Outcome('black', 1)).__repr__()) oneWin = noWins.nextWon() print(oneWin.currentBet()) twoWins = oneWin.nextWon() print(twoWins.currentBet()) threeWins = twoWins.nextWon() print(threeWins.currentBet())
def other(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Randomly bets to the lower probability (but higher reward) horse. Fallbacks to default. ''' lastHorseWeight = weights[-1] lastHorseMaxWeight = utils.MAX_HORSE_WEIGHTS[-1] sigma = lastHorseWeight / lastHorseMaxWeight betAmmount = int(balance * utils.PERCENAGE_FOR_BET * sigma) if random.random() < lastHorseMaxWeight: return Bet(5, betAmmount) return self.default(balance, rates, weights)
def __init__(self, bankroll=500): self.bet = Bet() self.point = None self.bankroll = bankroll # stats self.max_bank = bankroll self.min_bank = bankroll self.points_made = 0 self.seven_outs = 0 self.come_out_naturals = 0 self.come_out_craps = 0 self.longest_roll = 0 # logging self.history = OrderedDict() self.bankroll_history = [bankroll]
def _parse_live_marketblocks(self, bets, url): market_blocks = self.renderer.find_elements_by_class_name( 'markets--block') for mb in market_blocks: try: block_title_head = mb.find_element_by_class_name( 'markets--head').get_attribute('innerHTML') b = True for s in self._SKIP_TITLES: if s in block_title_head: b = False break if not b: # print(block_title_head) continue print(market_blocks.index(mb)) sub_block_titles = mb.find_elements_by_class_name( 'result--type--head') sub_blocks = mb.find_elements_by_class_name('outcome--list') for sub_block in sub_blocks: block_title_tail = ' ' + sub_block_titles[sub_blocks.index( sub_block)].find_element_by_tag_name( 'span').get_attribute('innerHTML') block_title = block_title_head + block_title_tail block = sub_block if mb.find_elements_by_class_name('mtype--7'): break else: labels = block.find_elements_by_tag_name('label') for label in labels: if label.get_attribute( 'class') == 'outcome--empty': continue bet_type = label.find_element_by_tag_name( 'span').get_attribute('title') bet_title = block_title + ' ' + bet_type button = label.find_element_by_tag_name('button') odds = button.text bet = Bet(bet_title, odds, self._NAME, url) bets.append(bet) except Exception: pass return bets
def from_dict(cls, match_dict): url = None date_time = None title = None key = list(match_dict.keys())[0] found = re.search(r'^(https://.+?) (.+?): (.+?)$', key) if found: url = found.group(1) date_time = DateTime.fromisoformat(found.group(2)) title = MatchTitle.from_str(found.group(3)) bets_dict = list(match_dict.values())[0][0] bets = [ Bet.from_dict({bet_title: odds}) for bet_title, odds in bets_dict.items() ] return cls(title, url, date_time, None, bets)
def default(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Always bets on the horse with the highest probability to win and compensates the lower probabilities by reducing the amount to bet: # ... sigma = horse_weight / max_horse_weight amount = amount * sigma # ... ''' firstRate = rates[0] firstWeight = weights[0] sigma = firstWeight / utils.MAX_FIRST_HORSE_WEIGHT betAmmount = int(balance * utils.PERCENAGE_FOR_BET * sigma) return Bet(0, betAmmount)
def get_odds_to_win(self, row, team, pinnacle): line_class = 'linesSpread' line = row.find_element_by_class_name(line_class) add_bet_line = line.get_attribute('onclick') if add_bet_line: bet_line = add_bet_line.split(',') odds = int(bet_line[5].replace("'", "")) pinnacle_odds = pinnacle.get_odds_to_win(team) if pinnacle_odds: bet = Bet( sport=self.sport, title=self.title, team=team, action_odds=odds, pinnacle_odds=pinnacle_odds, bet_type='ml', add_bet_line=add_bet_line, ) return bet
def _parse_marketblocks(self, bets, url): soup = self.renderer.soup() market_blocks = soup.find_all(class_='markets--block') try: for mb in market_blocks: block_title_head = mb.find(class_='markets--head').text b = True for s in FavoritScraper._SKIP_TITLES: if s in block_title_head: b = False break if not b: # print(block_title_head) continue # print(block_title_head) sub_block_titles = mb.find_all(class_='result--type--head') sub_blocks = mb.find_all(class_='outcome--list') for sub_block in sub_blocks: block_title_tail = ' ' + sub_block_titles[sub_blocks.index( sub_block)].find('span').text block_title = block_title_head + block_title_tail block = sub_block if mb.find_all(class_='mtype--7'): break else: labels = block.find_all('label') for label in labels: if label.get('class') == 'outcome--empty': continue bet_type = label.find('span').get('title') bet_title = block_title + ' ' + bet_type button = label.find('button') odds = button.text bet = Bet(bet_title, odds, FavoritScraper._NAME, url) bets.append(bet) except StaleElementReferenceException: self._parse_marketblocks(bets, url)
def __init__(self, minimum, player): self.bet = Bet() self.player = player self.dice = Dice() self.point = None self.minimum = minimum # metadata self.shooters = 1 self.rolls = 1 self.longest_roll = 0 self.points_won = 0 self.points_lost = 0 self.naturals_won = 0 self.naturals_lost = 0 self.come_out_naturals = 0 self.craps_won = 0 self.craps_lost = 0 self.come_out_craps = 0 self.roll_history = [] self.delta = (0, 0)
def _parse_marketblocks(self, bets, match_url): soup = self.renderer.soup() market_tables = soup.find_all(class_='marketTable__table___dvHTz') for mt in market_tables: flag = False table_title = mt.find( class_='marketTable__header___mSHxT').get('title') for title in self._BAD_TITLES: if title in table_title: flag = True buttons = mt.find_all('button') for button in buttons: bet = button.get('title') if bet != 'Deactivated': pos = bet.find(': ') bet_type = bet[:pos] if flag: bet_type = self.handle_flag_is_true_case( buttons, button, bet) odds = bet[pos + 2:] bet_title = table_title + ' ' + bet_type bet = Bet(bet_title, odds, self._NAME, match_url) bets.append(bet)
def scrape_match_bets(self, match: Match): t = time.time() self.renderer.get(match.url) self._open_bets() soup = self.renderer.soup() bet_groups = soup.find_all(class_='bet_group') for bet_group in bet_groups: bet_title = bet_group.find(class_='bet-title').text if ' '.join(bet_title.split()) in OneXBetScraper._SKIP_TITLES: continue if '\nSlider' in bet_title: bet_title = bet_title[:-len('\nSlider')] bet_types = [ el.text for el in bet_group.find_all(class_='bet_type') ] odds = [el.text for el in bet_group.find_all(class_='koeff')] for i in range(len(bet_types)): bet = Bet(bet_title + '. ' + bet_types[i], odds[i], OneXBetScraper._NAME, match.url) match.bets.append(bet) print(self._NAME, time.time() - t)
def bet(bets): initial_amount = get_amount_for_bet() max_martingale = get_bot_config()['max-martingale'] threads = [] for bet in bets: thread = Bet( kwargs={ 'api': API, 'bet': bet, 'initial_amount': initial_amount, 'max_martingale': max_martingale }) thread.start() threads.append(thread) for thread in threads: thread.join() check_needs_to_stop() sys.exit()
def test_win_loose(): zerozero = Outcome("00", 35) bet = Bet(10, zerozero) assert bet.win_amount() == 350
def setUp(self): self.outcome_five = Outcome("00-0-1-2-3", RouletteGame.FiveBet) self.outcome_zero = Outcome("Number 0", RouletteGame.StraightBet) self.bet_five = Bet(1000, self.outcome_five) self.bet_zero = Bet(1000, self.outcome_zero)
def next_bet(self): """ Implements Player.next_bet """ if self.red_count <= 0: black = self.table.wheel.get_outcome("Black") return Bet(self.bet_amount, black)
class Player(object): """Common base class for all players.\nDefault: 2x odds.""" def __init__(self, bankroll=500): self.bet = Bet() self.point = None self.bankroll = bankroll # stats self.max_bank = bankroll self.min_bank = bankroll self.points_made = 0 self.seven_outs = 0 self.come_out_naturals = 0 self.come_out_craps = 0 self.longest_roll = 0 # logging self.history = OrderedDict() self.bankroll_history = [bankroll] def add_money(self, amount): self.bankroll += amount self.update_max_min() def use_money(self, amount): if amount > self.bankroll: amount = self.bankroll self.bankroll -= amount self.update_max_min() return amount def update_max_min(self): self.max_bank = max(self.bankroll, self.max_bank) self.min_bank = min(self.bankroll, self.min_bank) def log_bankroll(self): self.bankroll_history.append(self.bankroll) def catalogue(self, table, log): self.history[table.rolls] = log self.longest_roll = max(self.longest_roll, table.dice.current_roll) def collect_wager(self): self.bankroll += self.bet.get_wager() self.log_bankroll() def tabulate(self): headers = ['#', 'Shooter', 'BankRoll', 'Wager', 'Dice', 'Point', 'Won', 'Lost'] print tabulate(self.history.values(), headers) print 'Wager on table: {}'.format(self.bet.get_wager()) print '\nBANKROLL: {} --> {}\n'.format(self.bankroll_history[0], self.bankroll_history[-1]) print 'MAX BANKROLL: {}\tMIN BANKROLL: {}'.format(self.max_bank, self.min_bank) print 'POINTS WON: {}\t\tSEVEN OUTS: {}'.format(self.points_made, self.seven_outs) print 'NATURALS: {}\t\tCRAPS: {}'.format(self.come_out_naturals, self.come_out_craps) print 'LONGEST ROLL: {}\tAVG ROLL: {}'.format(self.longest_roll, self.get_avg_roll()) # line_plot(self.bankroll_history) # pie_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values()) # bar_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values(), 11) def get_avg_roll(self): last_log = self.history[self.history.keys()[-1]] return last_log.rollNumber / float(last_log.shooter) @staticmethod def get_come_odds(number, amount): if number in (4, 5, 6, 8, 9, 10): return 2 * amount @staticmethod def get_dont_come_odds(number, amount): if number in (6, 8): return int(2.4 * amount) elif number in (5, 9): return 3 * amount elif number in (4, 10): return 4 * amount
def __init__(self, name, initBalance): self.name = name self.hand = Hand() self.wallet = Wallet(initBalance) self.bet = Bet()
def runMarketLoop(): t = time.localtime() current_time = time.strftime("%H:%M:%S", t) outputString = (current_time) for i in range(0, len(markets) - 1): market = markets[i] api_url = "https://www.predictit.org/api/marketdata/markets/" + str( market) r = requests.get(api_url) data = r.json() contracts = [] yesList = [] noList = [] for i in data['contracts']: yesCost = i["bestBuyYesCost"] noCost = i["bestBuyNoCost"] name = i['name'] if yesCost is None: yesList.append(-1) else: yesList.append(yesCost) if noCost is None: noList.append(-1) else: noList.append(noCost) yesList = sorted(yesList) noList = sorted(noList) yesProfit = [] noProfit = [] for i in yesList: if (i != -1): yesProfit.append(round((1 - i) * 0.9, 4)) else: yesProfit.append(-1) for i in noList: if (i != -1): noProfit.append(round((1 - i) * 0.9, 4)) else: noProfit.append(-1) #Calculating the yes profit yesSum = 0 for i in range(0, len(yesList) - 1): yesSum += yesList[i] if yesList[i] != -1 else yesSum yesSum = yesProfit[len(yesProfit) - 1] - yesSum #Calculating the no profit noSum = 0 for i in range(0, len(noProfit) - 1): noSum += noProfit[i] if noProfit[i] != -1 else noSum noSum = noSum - noList[len(noList) - 1] if len(marketsBetList) != len(markets): marketBet = Bet(market, -1, noSum, -1, -1) marketsBetList.append(marketBet) outputString += ("\n\nMarket: " + market) outputString += ("\nYes profit") outputString += ( "\n\t single: " + str(yesSum) + " \t max: " + str(math.floor(yesSum * (850 / yesList[len(yesList) - 1])))) outputString += ("\nNo profit") outputString += ( "\n\t single: " + str(noSum) + "\t max: " + str(math.floor(noSum * (850 / noList[len(noList) - 1])))) outputString += ( "\n____________________________________________________________________________" ) print(outputString) requests.post("WEBHOOK_LINK", {"content": outputString}) marketSort()
class Table(object): def __init__(self, minimum, player): self.bet = Bet() self.player = player self.dice = Dice() self.point = None self.minimum = minimum # metadata self.shooters = 1 self.rolls = 1 self.longest_roll = 0 self.points_won = 0 self.points_lost = 0 self.naturals_won = 0 self.naturals_lost = 0 self.come_out_naturals = 0 self.craps_won = 0 self.craps_lost = 0 self.come_out_craps = 0 self.roll_history = [] self.delta = (0, 0) def simulate(self): while self.stop_condition(): log = Log() self.player.strategy(self) log.pre_roll(self) self.shoot() self.delta = self.evaluate_roll() log.post_roll(self) self.player.catalogue(self, log) self.player.tabulate() def evaluate_roll(self): delta = (0, 0) if self.point is None: if self.dice.total in NATURALS: delta = self.bet.assess_naturals(self) self.come_out_naturals += 1 elif self.dice.total in CRAPS: delta = self.bet.assess_craps(self) self.come_out_craps += 1 elif self.dice.total in BOXES: delta = self.bet.assess_box(self) else: raise Exception('Invalid Roll') else: if self.dice.total == SEVEN: delta = self.bet.assess_seven_out(self) elif self.dice.total == YOLEVEN: delta = self.bet.assess_yoleven(self) elif self.dice.total in CRAPS: delta = self.bet.assess_craps(self) elif self.dice.total in BOXES: delta = self.bet.assess_box(self) else: raise Exception('Invalid Roll') self.player.log_bankroll() return delta def log(self): line_plot(self.bankroll_history) # pie_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values()) # bar_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values(), 11) def shoot(self): self.dice.roll() self.rolls += 1 return self.dice def stop_condition(self): if self.rolls == 100 or self.player.bankroll <= 0: return False else: return True def update_seven_out_stats(self): self.shooters += 1 self.longest_roll = max(self.longest_roll, self.dice.current_roll) self.dice.current_roll = 0