def assert_game_result(self, game: Game,
test_case: unittest.TestCase) -> None:
test_case.assertEqual(self.deuce, game.deuce())
test_case.assertEqual(self.player_busts, game.player_busts())
test_case.assertEqual(self.croupier_busts, game.croupier_busts())
test_case.assertEqual(self.croupier_wins, game.croupier_wins())
test_case.assertEqual(self.player_wins, game.player_wins())
class Strategy(object):
def __init__(self):
self.game = Game(mode="automated", print_games=False)
self.result = self.play()
def play(self):
while True:
game_result = self.decide()
if game_result:
break
return game_result
def decide(self):
raise NotImplementedError
def issue_command(self, cmd, game=None):
try:
if game:
game.dealer_command(cmd)
else:
self.game.dealer_command(cmd)
return None
except PlayerWins:
return "win"
except DealerWins:
return "lose"
except Push:
return "draw"
return None
def test_setup_new_game(self):
"""The method used to make sure that a new game can be properly set up."""
# Create a new game and make sure it has the correct settings
game = Game()
game.setup_new_game()
self.assertTrue(game.dealer is not None, msg="The dealer of the game was not created.")
self.assertEqual(game.dealer.cards, [])
self.assertEqual(game.state.name, "get_number_of_packs", msg="The initial game state was not correctly set.")
def main():
keep_playing = True
while keep_playing:
game = Game()
game.play()
answer = input(
"Do you want to play one more game? Type 'y' or 'n': ").lower().strip()
if answer == 'n':
keep_playing = False
print()
def test_start_ace_low():
# give
deck = _create_deck([1, 1], [3])
game = Game(deck)
# when
state = game.start()
# then
assert state['player_score'] == 12
assert state['player_has_ace'] == True
def test_start_state2():
# give
deck = [2, 3, 4]
game = Game(deck)
# when
state = game.start()
# then
assert state['player_score'] == 6
assert state['player_has_ace'] == False
assert state['dealer_score'] == 3
def test_start():
# give
deck = _create_deck([2, 4], [3])
game = Game(deck)
# when
state = game.start()
# then
assert state['player_score'] == 6
assert state['player_has_ace'] == False
assert state['dealer_score'] == 3
def simulateGames(n, model):
games = [0, 0, 0]
for i in range(n):
game = Game()
game.deal()
while hit(game.state(), model):
game.pPlay()
if game.player.bust():
break
game.dPlay()
games[game.result()] += 1
print(games)
async def blackjack(ctx):
server = ctx.message.server
server_id = ctx.message.server.id
player_id = ctx.message.author.id
game = Game(server, server_id, player_id, bot)
game.deal()
await game.play(ctx)
updated_money = Decimal(game.player.money).quantize(Decimal('.01'),
rounding=ROUND_DOWN)
db.update_money(server_id, player_id, updated_money)
return
def getSimulator(self, simulator):
if simulator == "logistics":
return Logistics(start=True)
elif simulator == "pong":
return Pong(start=True)
elif simulator == "tetris":
return Tetris(start=True)
elif simulator == "wumpus":
return Wumpus(start=True)
elif simulator == "blocks":
return Blocks_world(start=True)
elif simulator == "blackjack":
return Game(start=True)
elif simulator == "50chain":
return Chain(start=True)
elif simulator == "net_admin":
return Admin(start=True)
else:
print('{} is not a supported simulation'.format(simulator))
raise NameError()
class TestGame(unittest.TestCase):
def setUp(self):
self.player_hands = 4
self.game = Game(self.player_hands)
def test_deck(self):
self.assertEqual(self.game.deck.__class__, Deck)
def test_player_hands(self):
self.game.initial_deal()
self.assertEqual(self.player_hands, len(self.game.player_hands))
for hand in self.game.player_hands:
self.assertEqual(2, len(hand))
def test_dealer_hand(self):
self.game.initial_deal()
self.assertEqual(1, len(self.game.dealer_hand))
def test_initial_deal(self):
dealt_cards = self.game.deck.cards[0:9]
self.game.initial_deal()
self.assertEqual(dealt_cards[0], self.game.player_hands[0][0])
self.assertEqual(dealt_cards[1], self.game.player_hands[1][0])
self.assertEqual(dealt_cards[2], self.game.player_hands[2][0])
self.assertEqual(dealt_cards[3], self.game.player_hands[3][0])
self.assertEqual(dealt_cards[4], self.game.dealer_hand[0])
self.assertEqual(dealt_cards[5], self.game.player_hands[0][1])
self.assertEqual(dealt_cards[6], self.game.player_hands[1][1])
self.assertEqual(dealt_cards[7], self.game.player_hands[2][1])
self.assertEqual(dealt_cards[8], self.game.player_hands[3][1])
class TestGame(unittest.TestCase):
@classmethod
def setUp(self):
self.game = Game()
def test_generate_deck(self):
self.assertEqual(len(self.game.card_deck), 52)
def test_deal_hand(self):
hand = self.game.deal_hand()
self.assertEqual(len(hand), 2)
self.assertEqual(len(self.game.card_deck), 50)
def parse_mentions(self):
mentions = list(self.reddit.inbox.unread())
for mention in mentions:
user = sql.get_user(mention.author.name)
if 'deal me in' in mention.body.lower():
if not user.game:
logging.info('Dealing new hand to %s', user.name)
user.game = Game()
user.game.game_id = self.sql.insert_new_game(user)
self.sql.charge_user(user)
user.game.deal()
else:
self.generate_error_message(
mention,
"Invalid action - user already has game active")
# Write logic for variable bets here
# Need to find "bet" in string, then parse out the following int
if re.match(r"\bhit\b", mention.body.lower()):
if user.game and user.game.can_hit():
logging.info('%s hits', user.name)
user.game.player_hit()
else:
logging.info('%s invalid hit', user.name)
self.generate_error_message(
mention,
"Invalid action - Hit not allowed in game state")
if re.match(r"\bstay\b", mention.body.lower()):
logging.info('%s stays', user.name)
if user.game:
user.game.player_stay()
user.game.dealer_play()
else:
logging.info('%s invalid stay', user.name)
self.generate_error_message(
mention,
"Invalid action - Stay not allowed without active game"
)
if user.game:
mention.reply(self.generate_reply(user.game))
# print(self.generate_reply(user.game))
self.sql.store_hand_state(user)
if user.game.game_complete:
logging.info('Game complete. User: %s - Game ID: %s',
user.name, user.game.game_id)
self.sql.pay_user(user)
mention.mark_read()
def simulateGames():
game = Game()
game.deal()
game.dPlay()
while True:
#cardState = game.state()
########################################################
"""
hard, value = hardValue(game.player)
deal = game.dealer.value()
if hard:
if value <= 11:
hit = 1
elif value == 12:
if 4 <= deal <= 6:
hit = 0
else:
hit = 1
elif 13 <= value <= 16:
if 2 <= deal <= 6:
hit = 0
else:
hit = 1
elif value >= 17:
hit = 0
else:
if value <= 17:
hit = 1
elif value == 18:
if deal in [9,10,11]:
hit = 1
else:
hit = 0
else:
hit = 0
"""
state, hit = strat(game)
states.append(state)
hits.append(hit)
########################################################
if game.player.bust():
break
game.pPlay()
def parse():
f = open("log.txt")
line = f.readline()
while line != "":
hand, dealer, move, outcome = line.split(" ")
key = hand, dealer
move_key = int(float(move))
outcome_key = int(float(outcome))
if key not in Parser.freq:
Parser.freq[key] = {
Player.move("HIT"): [0,0],
Player.move("STAY"): [0,0]
}
if outcome_key == Game.round_outcome("WIN"):
Parser.freq[key][move_key][0] += 1
Parser.freq[key][move_key][1] += 1
line = f.readline()
f.close()
def __init__(self, strategy="advanced"):
self.strategy = Strategy(strategy)
Game.__init__(self)
def test_deal(self):
rand.seed(7)
game = Game()
game.deal()
result = game.dealer.hand[1].val == 3
self.assertTrue(result)
def game():
game = Game()
return game
def test_set_pack_number(self):
"""The method used to make sure that the number of packs of cards used in the deck can be set."""
# Setup new games and attempt to set their number of packs
valid_packs = [
1,
2,
3,
4,
5,
100,
]
for packs in valid_packs:
game = Game()
game.setup_new_game()
self.assertEqual(game.state.name, "get_number_of_packs", msg="The initial game state was not correctly set.")
game.set_pack_number(packs)
self.assertEqual(len(game.deck), packs * 52, msg="The number of packs was not correctly set with " + str(packs) + " packs.")
# Make sure that the new game state was correctly set
self.assertEqual(game.state.name, "get_player_chips", msg="The game state after setting the number of packs was not correctly set.")
# Try to set invalid pack numbers
invalid_packs = [
-1,
0,
-100,
1.5,
]
for packs in invalid_packs:
game = Game()
game.setup_new_game()
self.assertEqual(game.state.name, "get_number_of_packs", msg="The initial game state was not correctly set.")
success = False
try:
game.set_pack_number(packs)
except InvalidPackNumber:
success = True
self.assertTrue(success, msg="An invalid number of packs " + str(packs) + " was able to be set.")
# Try to reset the number of packs to throw an error
game = Game()
game.setup_new_game()
self.assertEqual(game.state.name, "get_number_of_packs", msg="The initial game state was not correctly set.")
game.set_pack_number(1)
success = False
try:
game.set_pack_number(1)
except InvalidGameMethodOrder:
success = True
self.assertTrue(success, msg="The number of packs in a deck was incorrectly able to be reset.")
from blackjack import Game blackjack_game = Game() blackjack_game.start_game() blackjack_game.stop_game()
def test_set_starting_chips(self):
"""The method used to make sure that the number of starting chips for each player can be set."""
# Setup new game and attempt to set their valid number of starting chips
valid_chips = [
1,
10,
100,
9999,
]
for chips in valid_chips:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(chips)
self.assertEqual(game.starting_chips, chips, msg="The number of player starting chips was not correctly set with " + str(chips) + " chips.")
# Make sure that the new game state was correctly set
self.assertEqual(game.state.name, "get_number_of_players", msg="The game state was not correctly set after setting the number of starting chips.")
# Try to set invalid chip numbers
invalid_chips = [
0,
-1,
-100,
1.5,
-1.5,
]
for chips in invalid_chips:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
success = False
try:
game.set_starting_chips(chips)
except InvalidGameStartingChips:
success = True
self.assertTrue(success, msg="An invalid number of starting chips " + str(chips) + " was able to be set.")
# Try to reset the number of starting chips to throw an error
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
success = False
try:
game.set_starting_chips(200)
except InvalidGameMethodOrder:
success = True
self.assertTrue(success, msg="The number of starting chips was incorrectly able to be reset.")
def compute_transfer_model(self):
X,Y,bk = [],[],[]
i = 0
values = {}
while i < self.transfer+1: #at least one iteration burn in time
if self.simulator == "logistics":
state = Logistics(number = self.state_number,start=True)
if not bk:
bk = Logistics.bk
elif self.simulator == "pong":
state = Pong(number = self.state_number,start=True)
if not bk:
bk = Pong.bk
elif self.simulator == "tetris":
state = Tetris(number = self.state_number,start=True)
if not bk:
bk = Tetris.bk
elif self.simulator == "wumpus":
state = Wumpus(number = self.state_number,start=True)
if not bk:
bk = Wumpus.bk
elif self.simulator == "blocks":
state = Blocks_world(number = self.state_number,start=True)
if not bk:
bk = Blocks_world.bk
elif self.simulator == "blackjack":
state = Game(number = self.state_number,start=True)
if not bk:
bk = Game.bk
elif self.simulator == "50chain":
state = Chain(number = self.state_number,start=True)
if not bk:
bk = Chain.bk
elif self.simulator == "net_admin":
state = Admin(number = self.state_number,start=True)
if not bk:
bk = Admin.bk
with open(self.simulator+"_transfer_out.txt","a") as f:
if self.transfer:
f.write("start state: "+str(state.get_state_facts())+"\n")
time_elapsed = 0
within_time = True
start = clock()
trajectory = [(state.state_number,state.get_state_facts())]
while not state.goal():
if self.transfer:
f.write("="*80+"\n")
state_action_pair = state.execute_random_action()
state = state_action_pair[0] #state
if self.transfer:
f.write(str(state.get_state_facts())+"\n")
trajectory.append((state.state_number,state.get_state_facts()))
end = clock()
time_elapsed = abs(end-start)
if self.simulator == "logistics" and time_elapsed > 0.5:
within_time = False
break
elif self.simulator == "pong" and time_elapsed > 1000:
within_time = False
break
elif self.simulator == "tetris" and time_elapsed > 1000:
within_time = False
break
elif self.simulator == "wumpus" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "blocks" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "blackjack" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "50chain" and time_elapsed > 2:
within_time = False
break
elif self.simulator == "net_admin" and time_elapsed > 1:
within_time = False
break
if within_time:
self.compute_value_of_trajectory(values,trajectory)
self.state_number += len(trajectory)+1
for key in values:
state = list(key[1])
value = values[key]
X.append(state)
Y.append(value)
'''
for key in values:
facts += list(key[1])
example_predicate = "value(s"+str(key[0])+") "+str(values[key])
examples.append(example_predicate)
'''
i += 1
npX = np.array(X)
npY = np.array(Y)
if not self.transfer:
npY = np.zeros(len(npY))
model = MLPRegressor(hidden_layer_sizes=(25,),
activation="logistic",
solver="lbfgs",
alpha=0.0001,
batch_size="auto",
learning_rate="constant",
learning_rate_init=0.001,
power_t=0.5,
max_iter=200,
shuffle=True,
random_state=None,
tol=0.0001,
verbose=False,
warm_start=False,
momentum=0.9,
nesterovs_momentum=True,
early_stopping=False,
validation_fraction=0.1,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08)
print (npX)
model.fit(npX,npY)
#reg = GradientBoosting(regression = True,treeDepth=2,trees=self.trees,sampling_rate=0.7,loss=self.loss)
#reg.setTargets(["value"])
#reg.learn(facts,examples,bk)
self.model = model
self.AVI()
def test_set_player_names(self):
"""The method used to make sure that the names of the players in the game can be set."""
# Setup new games and attempt to set their players' names
valid_players = [
["Bob", "Sam", "Cal", "Kris"],
["Player 1", "Player 2", "Player 3", "Player 4", "Player 5"],
["Bot"],
["P1", "P2", "P3"],
]
for players in valid_players:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(len(players))
game.set_player_names(players)
self.assertEqual(game.player_names, players, msg="The game's player names were not correctly set with: " + str(players))
# Make sure that the new game state is corectly set
self.assertEqual(game.state.name, "start_game", msg="The game's state was not correctly set after setting the player names.")
# Try to set invalid players
invalid_players = [
None,
[None, None],
[123, 456, 789],
["Bob", "Sam", 123],
["John", ""],
]
for players in invalid_players:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(len(players or "1"))
success = False
try:
game.set_player_names(players)
except InvalidGamePlayerNames:
success = True
self.assertTrue(success, msg="The following invalid series of player names was able to be set: " + str(players))
# Test the case where the number of players given is not the same as the number of names given
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(2)
success = False
try:
game.set_player_names(["P1", "P2", "P3"])
except InvalidGamePlayerNames:
success = True
self.assertTrue(success, msg="A number of player names unequal to the number to the number of players in the game was able to be set.")
# Try to reset the names of the players to throw an error
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(3)
game.set_player_names(["P1", "P2", "P3"])
success = False
try:
game.set_player_names(["P01", "P02", "P03"])
except InvalidGameMethodOrder:
success = True
self.assertTrue(success, msg="The names of the players was incorrectly able to be reset.")
loops = 0
while True:
loops += 1
print("Loop {}".format(loops))
try:
for subreddit in config.SUBREDDITS:
sub = reddit.subreddit(subreddit)
for post in sub.new():
# TODO: Check if the post itself contains a summon
for comment in post.comments:
for summon in config.SUMMON_STRINGS:
if summon in comment.body.lower():
# TODO: Check if bot has already responded to this comment
print(
"Summoned by {} in thread {}. Comment ID: {}"
.format(comment.author, post.title,
comment.id))
d = Game()
d.deal()
reply = d.get_reddit_reply()
comment.reply(reply)
except KeyboardInterrupt:
sys.exit()
except praw.exceptions.APIException as e:
# TODO: Investigate if this catches only rate limit exceptions, or more
print(e)
print("Rate limit exceeded. Sleeping for 10 minutes.")
time.sleep(60)
except Exception as e:
print("EXCEPTION: {}".format(e))
def setUp(self):
self.game = Game()
self.game_10_decks = Game(number_of_decks=10)
import random
import time
import io
import pandas as pd
from blackjack import Game
from strategy import HitStandTrainStrategy, HitStandTestStrategy
if __name__ == '__main__':
algorithm = "OriginalPrototypeRandomExploration"
test_train_iterations_to_run = 100000
seconds_to_run = 60
original_prototype_seconds_to_run = time.time()
game = Game(1, reset_on_dealer_blackjack=True)
# Train by playing X games randomly, then use that knowledge to play another X games intelligently
if algorithm == "TrainAndTest":
# Generating a
training_results = [[{
'STAND': {
'WIN': 0,
'LOSE': 0,
'DRAW': 0
},
'HIT+STAND': {
'WIN': 0,
'LOSE': 0,
'DRAW': 0
}
def test_a_game_has_many_players():
players = [Player(), Player(), Player()]
game = Game(*players)
assert set(game.players) == set(players)
def main():
player_original_cash_balance = 200
blackjack = Game(name_player='player',
player_cash_balance=player_original_cash_balance,
dealer_cash_balance=1000,
number_of_decks=1)
blackjack.welcome()
round_number = 1
while blackjack.player_cash_balance >= blackjack.player.minimum_bet:
print(f'''
********************
ROUND {round_number}
********************
''')
(player_bet, dealer_bet) = blackjack.bets()
blackjack.deal_cards()
blackjack.player.show_balance()
blackjack.player.show_player_card_values()
if blackjack.player.hand.get_card_value() < 21:
blackjack.adjust_player_hand()
blackjack.adjust_dealer_hand()
blackjack.dealer.show_dealer_card_values()
blackjack.blackjack_result(player_bet, dealer_bet)
exit_game = blackjack.exit_game()
if exit_game == True:
print('Thank you for playing with us')
if blackjack.gain_losses(player_original_cash_balance) > 0:
print(
f'You gained: {blackjack.gain_losses(player_original_cash_balance)} $.'
)
elif blackjack.gain_losses(player_original_cash_balance) < 0:
print(
f'You lost: {blackjack.gain_losses(player_original_cash_balance)} $.'
)
elif blackjack.gain_losses(player_original_cash_balance) == 0:
print(f'You broke even.')
sys.exit()
discard_pot = blackjack.collect_and_discard_card()
blackjack.return_cards_to_deck_and_reshuffle(discard_pot)
round_number += 1
else:
'Sorry you no longer have a balance to play. You lost everything.'
from blackjack import MCPolicyEvaluationAgent, Game
from mpl_toolkits.mplot3d import axes3d
import matplotlib.pylab as plt
import numpy as np
player = MCPolicyEvaluationAgent()
game = Game(player=player)
game.verbose = False
for n in range(200000):
game.init()
game.play()
print(player.values)
print(player.counts)
faceup = range(1, 11)
sum = range(12, 22)
X, Y = np.meshgrid(sum, faceup)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_aspect('equal')
ax.plot_wireframe(X, Y, player.values[0], label='No Usable Ace')
ax.plot_wireframe(X, Y, player.values[1], color='red', label='Usable Ace')
ax.set_zlim(-1, 1)
ax.set_xticks(sum)
def setUp(self):
self.game = Game()
def test_a_game_auto_plays_until_someone_has_zero_dollars():
game = Game(Player(), Player(), Player())
turns = game.auto_play()
assert turns > 0
assert any(p.bank == 0 for p in game.players)
def main():
"""Plays the Game"""
os.system('clear')
player_name = input("Please enter your name: ")
p1 = HumanPlayer(player_name, BlackjackHand())
print("\nWelcome to Bull City Bets - an exclusive Blackjack Casino!\n\n")
while True:
d1 = Dealer("dealer", BlackjackHand())
deck = Deck()
g = Game(p1, d1, deck)
print("\nAnte Up!")
p1.place_bet()
g.add_bet()
print("Total Pot: {} Player Purse: {}".format(g.pot, p1.purse))
if not g.check_initial_blackjack():
g.player_turn()
g.dealer_turn()
g.print_results()
g.play_again()
def contGame(model):
while True:
game = Game()
game.deal()
printLine()
game.printResult()
printLine()
while hit(game.state(), model):
game.pPlay()
game.dPlay()
game.printResult()
printLine()
n = input("\n\nQuit?(y/n):")
if n == "y":
break
from blackjack import Game game = Game() game.verbose = True game.init() game.play() print(game.player.history) print(game.dealer.history)
class TestGame(unittest.TestCase):
def setUp(self):
self.game = Game()
self.game_10_decks = Game(number_of_decks=10)
def tearDown(self):
del self.game
del self.game_10_decks
def test_game_blackjack_check_numbers_of_decks(self):
self.assertEqual(len(self.game_10_decks.dealer.deck), 520,
'Number of decks is not correct.')
def test_game_blackjack_payout_dealer_bet_float(self):
self.assertEqual(type(self.game.blackjack_payout(10.00)), int,
'Blackjack payout not returning int.')
def test_game_blackjack_payout_dealer_bet_int(self):
self.assertEqual(type(self.game.blackjack_payout(10)), int,
'Blackjack payout not returning int.')
def test_game_blackjack_payout_dealer_bet_negative(self):
self.assertGreaterEqual(
self.game.blackjack_payout(-10), 15,
'Blackjack payout not returning positive 3:2 blackjack payout.')
def test_game_blackjack_payout_dealer_bet_zero(self):
self.assertEqual(
self.game.blackjack_payout(0), 0,
'Blackjack payout not returning zero whe zero inputed.')
def test_game_blackjack_payout_dealer_bet_positive(self):
self.assertGreaterEqual(
self.game.blackjack_payout(10), 15,
'Blackjack payout not returning 3:2 blackjack payout.')
def test_game_blackjack_result_blackjack_player_wins_dealer_hand_value_less_than_21(
self):
self.game.player.hand.add_card(
[Card('Hearts', 'Ace'),
Card('Spades', 'King')])
self.game.dealer.hand.add_card([
Card('Hearts', 'Three'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, 125,
'Blackjack result is not working for player balckjack.')
def test_game_blackjack_result_blackjack_player_wins_dealer_hand_value_more_than_21(
self):
self.game.player.hand.add_card(
[Card('Hearts', 'Ace'),
Card('Spades', 'King')])
self.game.dealer.hand.add_card([
Card('Hearts', 'Three'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, 125,
'Blackjack result is not working for player blackjack.')
def test_game_blackjack_result_player_bust_dealer_less_than_21(self):
self.game.player.hand.add_card([
Card('Hearts', 'Queen'),
Card('Spades', 'King'),
Card('Diamonds', 'Four')
])
self.game.dealer.hand.add_card(
[Card('Hearts', 'Two'),
Card('Spades', 'Queen')])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.dealer.cash_balance, 120,
'Blackjack result not working when player busts and dealer has low card values'
)
def test_game_blackjack_result_player_bust_dealer_more_than_21_equal_to_hand_player(
self):
self.game.player.hand.add_card([
Card('Hearts', 'Two'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.dealer.hand.add_card([
Card('Hearts', 'Two'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.dealer.cash_balance, 120,
'Blackjack result not working when player busts and dealer has equal card values'
)
def test_game_blackjack_result_player_bust_dealer_more_than_21_superior_to_hand_player(
self):
self.game.player.hand.add_card([
Card('Hearts', 'Two'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.dealer.hand.add_card([
Card('Hearts', 'Four'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.dealer.cash_balance, 120,
'Blackjack result not working when player busts and dealer has higher card values'
)
def test_game_blackjack_result_player_wins_dealer_bust_higher_than_21(
self):
self.game.player.hand.add_card(
[Card('Hearts', 'King'),
Card('Spades', 'Eight')])
self.game.dealer.hand.add_card([
Card('Hearts', 'Four'),
Card('Spades', 'King'),
Card('Diamonds', 'Queen')
])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, 120,
'Blackjack result not working when player wins, dealer busts with card values superior to 21.'
)
def test_game_blackjack_result_player_wins_dealer_bust_21(self):
self.game.player.hand.add_card(
[Card('Hearts', 'King'),
Card('Spades', 'Eight')])
self.game.dealer.hand.add_card(
[Card('Hearts', 'Ace'),
Card('Spades', 'King')])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, 120,
'Blackjack result not working when player wins, dealer busts with card values equal to 21.'
)
def test_game_blackjack_result_dealer(self):
self.game.player.hand.add_card(
[Card('Hearts', 'King'),
Card('Spades', 'Eight')])
self.game.dealer.hand.add_card(
[Card('Hearts', 'King'),
Card('Spades', 'Nine')])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.dealer.cash_balance, 120,
'Blackjack result not working when dealer wins and player card values less than 21.'
)
def test_game_blackjack_result_tie_blackjack(self): # == > tie not working
self.game.player.hand.add_card(
[Card('Hearts', 'Ace'),
Card('Spades', 'King')])
self.game.dealer.hand.add_card(
[Card('Diamonds', 'Ten'),
Card('Clubs', 'Ace')])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, self.game.dealer.cash_balance,
'Blackjack result not working when dealer and player tie at 21.')
def test_game_blackjack_result_tie_less_than_blackjack(self):
self.game.player.hand.add_card(
[Card('Hearts', 'Seven'),
Card('Spades', 'King')])
self.game.dealer.hand.add_card(
[Card('Diamonds', 'Ten'),
Card('Clubs', 'Seven')])
self.game.blackjack_result(10, 10)
self.assertEqual(
self.game.player.cash_balance, self.game.dealer.cash_balance,
'Blackjack result not working when dealer and player tie at value less than 21.'
)
def __init__(self):
self.game = Game(mode="automated", print_games=False)
self.result = self.play()
def AVI(self):
for i in range(self.number_of_iterations):
j = 0
X,Y,bk = [],[],[]
values = {}
fitted_values = {}
while j < self.batch_size:
if self.simulator == "logistics":
state = Logistics(number = self.state_number,start=True)
if not bk:
bk = Logistics.bk
elif self.simulator == "pong":
state = Pong(number = self.state_number,start=True)
if not bk:
bk = Pong.bk
elif self.simulator == "tetris":
state = Tetris(number = self.state_number,start=True)
if not bk:
bk = Tetris.bk
elif self.simulator == "wumpus":
state = Wumpus(number = self.state_number,start=True)
if not bk:
bk = Wumpus.bk
elif self.simulator == "blocks":
state = Blocks_world(number = self.state_number,start=True)
if not bk:
bk = Blocks_world.bk
elif self.simulator == "blackjack":
state = Game(number = self.state_number,start=True)
if not bk:
bk = Game.bk
elif self.simulator == "50chain":
state = Chain(number = self.state_number,start=True)
if not bk:
bk = Chain.bk
elif self.simulator == "net_admin":
state = Admin(number = self.state_number,start=True)
if not bk:
bk = Admin.bk
with open(self.simulator+"_FVI_out.txt","a") as fp:
fp.write("*"*80+"\nstart state: "+str(state.get_state_facts())+"\n")
time_elapsed = 0
within_time = True
start = clock()
trajectory = [(state.state_number,state.get_state_facts())]
while not state.goal():
fp.write("="*80+"\n")
state_action_pair = state.execute_random_action()
state = state_action_pair[0]
fp.write(str(state.get_state_facts())+"\n")
trajectory.append((state.state_number,state.get_state_facts()))
end = clock()
time_elapsed = abs(end-start)
if self.simulator == "logistics" and time_elapsed > 0.5:
within_time = False
break
elif self.simulator == "pong" and time_elapsed > 1000:
within_time = False
break
elif self.simulator == "tetris" and time_elapsed > 10:
within_time = False
break
elif self.simulator == "wumpus" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "blocks" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "blackjack" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "50chain" and time_elapsed > 1:
within_time = False
break
elif self.simulator == "net_id" and time_elapsed > 1:
within_time = False
if within_time:
if i > 0:
self.compute_value_of_trajectory(values,trajectory,AVI=True)
else:
self.compute_value_of_trajectory(values,trajectory,AVI=False)
self.state_number += 1
for key in values:
state = list(key[1])
value = values[key]
#X.append(state)
fitted_values[key] = self.model.predict(np.array([state]))
#Y.append([value])
'''
for key in values:
facts += list(key[1])
example_predicate = "value(s"+str(key[0])+") "+str(values[key])
examples.append(example_predicate)
'''
j += 1
#fitted_values = self.model.predict(np.array(X))
bellman_error = self.compute_bellman_error(values,fitted_values)
with open(self.simulator+"_BEs.txt","a") as f:
f.write("iteration: "+str(i)+" average bellman error: "+str(bellman_error)+"\n")
for key in values:
X.append(list(key[1]))
Y.append(values[key])
npX = np.array(X)
npY = np.array(Y)
self.model.fit(npX,npY)
def decide(self):
moves = ["hit", "stay"]
results_by_first_move = {
"hit": {
"games": 0,
"wins": 0,
},
"stay": {
"games": 0,
"wins": 0,
}
}
for _ in range(100):
# clone the current game, using list() so we don't pass references
simulated_game = Game(mode="automated")
simulated_game.dealer_hand = list(self.game.dealer_hand)
simulated_game.player_hand = list(self.game.player_hand)
self.debug(simulated_game)
# make a first move, see if the game ends
first_move = random.choice(moves)
self.debug("- first move {}".format(first_move))
game_result = self.issue_command(first_move, game=simulated_game)
if game_result:
results_by_first_move[first_move]["games"] += 1
if game_result == "win":
self.debug(" - won on first move")
results_by_first_move[first_move]["wins"] += 1
else:
self.debug(" - lost on first move")
else: # continue playing the game randomly and see what happens
while True:
game_result = self.issue_command(random.choice(moves),
game=simulated_game)
if game_result:
break
results_by_first_move[first_move]["games"] += 1
if game_result == "win":
self.debug(" - won on subsequent move")
results_by_first_move[first_move]["wins"] += 1
else:
self.debug(" - lost on subsequent move")
# print simulated_game
self.info("=============")
self.info(results_by_first_move)
# calculate the win pct for both first moves
hit_win_pct = results_by_first_move["hit"]["wins"] / float(
results_by_first_move["hit"]["games"])
stay_win_pct = results_by_first_move["stay"]["wins"] / float(
results_by_first_move["stay"]["games"])
# issue the winning command
if hit_win_pct > stay_win_pct:
self.info("=> choosing to 'hit' with a {}% win rate".format(
hit_win_pct * 100))
return self.issue_command("hit")
else:
self.info("=> choosing to 'stay' with a {}% win rate".format(
stay_win_pct * 100))
return self.issue_command("stay")
def setUp(self):
self.player_hands = 4
self.game = Game(self.player_hands)
def test_set_players_number(self):
"""The method used to make sure that the number of players in the game can be set."""
# Setup new games and attempt to set thier number of players
valid_players = [
1,
2,
10,
999,
]
for players in valid_players:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(players)
self.assertEqual(game.players_number, players, msg="The number of players was not correctly set with " + str(players) + " players.")
# Make sure that the new game state is correctly set
self.assertEqual(game.state.name, "get_player_names", msg="The game state was not correctly set after setting the number of players in the game.")
# Try to set invalid player numbers
invalid_players = [
0,
-1,
-100,
1.5,
]
for players in invalid_players:
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
success = False
try:
game.set_players_number(players)
except InvalidGamePlayersNumber:
success = True
self.assertTrue(success, msg="An invalid number of players " + str(players) + " was able to be set.")
# Try to reset the number of players to throw an error
game = Game()
game.setup_new_game()
game.set_pack_number(1)
game.set_starting_chips(100)
game.set_players_number(3)
success = False
try:
game.set_players_number(2)
except InvalidGameMethodOrder:
success = True
self.assertTrue(success, msg="The number of players was incorrectly able to be reset.")
