def create_room(server, client, options):
new_game = Game()
if options and 'room_id' in options:
new_game = Game(options['room_id'])
new_game.add_player(client)
new_game_id = new_game.get_id()
server.rooms[new_game_id] = new_game
client.send_action(200, {'id': new_game_id})
return
def test_input_within_range(self):
''' Test if input is within 1 to 3 '''
game = Game()
self.assertTrue(game.is_input_within_range(1, 3))
self.assertFalse(game.is_input_within_range(0, 3))
self.assertFalse(game.is_input_within_range(-3, 1000))
def __init__(self, size: int = 10,
parent: Optional[QWidget] = None,
*args, **kwargs) -> None:
super(Canvas, self).__init__(*args, **kwargs)
self._qp = QPainter()
self._timer = QTimer()
self._timer.timeout.connect(self.redraw)
self._colors = {
0: {
'cells': QColor('green'),
'background': QColor('white'),
'grid': QColor('black')
}, 1: {
'cells': QColor('black'),
'background': QColor('white'),
'grid': QColor('black')
}}
self.next_generation_signal = GenerationUpdateSignal()
self.game = Game()
self.size = size
self._color_scheme = self._colors[0]
self._grid = []
self._rects = []
def run():
n = 4
width, height = 6, 6
model_file = os.path.join(results_dir, "zero_17_4_15:36",
"policy_1450.model")
try:
board = Board(width=width, height=height, n_in_row=n)
game = Game(board)
# ############### human VS AI ###################
# load the trained policy_value_net in either Theano/Lasagne, PyTorch or TensorFlow
best_policy = PolicyValueNet(width, height, model_file=model_file)
mcts_player = MCTSPlayer(best_policy.policy_value_fn,
c_puct=5,
n_playout=400)
# uncomment the following line to play with pure MCTS (it's much weaker even with a larger n_playout)
# mcts_player = MCTS_Pure(c_puct=5, n_playout=1000)
# human player, input your move in the format: 2 3
human = Human()
# set start_player=0 for human first
game.start_play(human, mcts_player, start_player=1, is_shown=1)
except KeyboardInterrupt:
print('\n\rquit')
def __init__(self):
self.screen = pygame.display.set_mode((Settings.multi_screen_width,
Settings.screen_height))
self.menu_button = Button(self.screen,
(Settings.multi_screen_width - Settings.button_width) // 2,
Settings.screen_height * 0.9,
'BACK TO MENU')
self.game1 = Game(self.screen, 0,
pygame.K_a, pygame.K_d, pygame.K_w, pygame.K_s, pygame.K_ESCAPE)
self.game2 = Game(self.screen, Settings.single_screen_width,
pygame.K_LEFT, pygame.K_RIGHT, pygame.K_UP, pygame.K_DOWN, pygame.K_SPACE)
self.winner_alert = None
def setUp(self):
self.board_3x3 = Board(3)
self.board_5x5 = Board(5)
self.game = Game()
self.game.board = Board(3)
self.game.player1 = Player("Toothless", "X")
self.game.player2 = Player("Hiccup", "O")
def __init__(self):
super().__init__()
# Determine what controller type should be used
num_args = len(sys.argv)
self.control_type = "keyboard"
if num_args > 1:
self.control_type = sys.argv[1].lower()
# Init control input
if self.control_type == "controller":
# Init pygame controller input
print("Initiated controller")
pygame.joystick.init()
self.joystick = pygame.joystick.Joystick(0)
self.joystick.init()
pygame.init()
elif self.control_type == "keyboard":
pass
else:
print("INVALID CONTROL TYPE")
return
# Init game
self.game = Game()
self.canvas.add(self.game)
def test_game_failure_if_straight_continous_blocks(self):
board = TicTacBoard(3)
game = Game(board, Difficult_level.MEDIUM)
board.place_position((0, 0), "O")
board.place_position((0, 1), "X")
board.place_position((0, 2), "O")
self.assertEqual(game.is_completed_with_win(board.grid), DRAW)
def main():
game = Game(PlayAgainstQExperiment())
if game.do_render:
screen = Screen(game.game_state)
clock = pygame.time.Clock()
while screen.running:
for event in pygame.event.get():
if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
and event.key
== pygame.K_ESCAPE):
screen.running = False
game.update()
screen.update()
# wait for next frame
clock.tick(60)
pygame.quit()
else:
while game.playing:
game.update()
def PlayGames(player1, player2, numgames):
victories1 = 0
victories2 = 0
for _ in range(numgames):
game = Game(n_players=2,
dice_number=4,
dice_value=3,
column_range=[2, 6],
offset=2,
initial_height=1)
is_over = False
who_won = None
number_of_moves = 0
current_player = game.player_turn
while not is_over:
moves = game.available_moves()
if game.is_player_busted(moves):
if current_player == 1:
current_player = 2
else:
current_player = 1
continue
else:
if game.player_turn == 1:
chosen_play = player1.get_action(game)
else:
chosen_play = player2.get_action(game)
if chosen_play == 'n':
if current_player == 1:
current_player = 2
else:
current_player = 1
#print('Chose: ', chosen_play)
#game.print_board()
game.play(chosen_play)
#game.print_board()
number_of_moves += 1
#print()
who_won, is_over = game.is_finished()
if number_of_moves >= 200:
is_over = True
who_won = -1
#print('No Winner!')
if who_won == 1:
victories1 += 1
if who_won == 2:
victories2 += 1
#print(victories1, victories2)
#print('Player 1: ', victories1 / (victories1 + victories2))
#print('Player 2: ', victories2 / (victories1 + victories2))
if victories1 + victories2 == 0:
return (0, 0)
p1victoryrate = victories1 / (victories1 + victories2)
p2victoryrate = 1 - p1victoryrate
return (p1victoryrate, p2victoryrate)
def main():
run = True
clock = pygame.time.Clock()
game = Game(WIN)
SPAWNPIPE = pygame.USEREVENT
pygame.time.set_timer(SPAWNPIPE, 1200)
BIRDFLAP = pygame.USEREVENT + 1
pygame.time.set_timer(BIRDFLAP, 200)
while run:
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and game.ACTIVE == True:
Bird.BIRD_MOVE = 0
Bird.BIRD_MOVE -= 5
FLAP_SOUND.play()
if event.key == pygame.K_SPACE and game.ACTIVE == False:
game.reset()
if event.type == SPAWNPIPE:
game.create_pipe()
if event.type == BIRDFLAP:
game.bird_animation()
game.update()
pygame.quit()
def test_game_settle(prints, player_cards, dealer_cards, player_bet,
expected_player_purse):
"""
Round of Blackjack settled.
"""
def test_print(message):
_print = prints.pop(0)
assert message == _print
game = Game(_print=test_print)
game.get_player().get_hand().set_cards(player_cards)
game.get_dealer().get_hand().set_cards(dealer_cards)
game.get_player().make_bet(player_bet)
game.settle()
expected_player_cards = []
expected_player_bet = 0
expected_player_purse = expected_player_purse
expected_dealer_cards = []
actual_player_cards = game.get_player().get_hand().get_cards()
actual_player_bet = game.get_player().get_bet().get_size()
actual_player_purse = game.get_player().get_purse().get_size()
actual_dealer_cards = game.get_dealer().get_hand().get_cards()
assert actual_player_cards == expected_player_cards
assert actual_player_bet == expected_player_bet
assert actual_player_purse == expected_player_purse
assert actual_dealer_cards == expected_dealer_cards
def test_game_deal():
"""
A hand is dealt to a player and a dealer.
"""
def _random(start, end):
return start
game = Game(_random=_random)
game.deal()
hidden_card = Card('Clubs', '4')
hidden_card.set_hidden(True)
expected_dealer_cards = [Card('Clubs', '2'), hidden_card]
expected_player_cards = [Card('Spades', 'Ace'), Card('Clubs', '3')]
actual_dealer_cards = game.get_dealer().get_hand().get_cards()
actual_player_cards = game.get_player().get_hand().get_cards()
assert len(actual_dealer_cards) == len(expected_dealer_cards)
for i in range(len(actual_dealer_cards)):
assert actual_dealer_cards[i].get_suit(
) == expected_dealer_cards[i].get_suit()
assert actual_dealer_cards[i].get_pip(
) == expected_dealer_cards[i].get_pip()
assert actual_dealer_cards[i].get_hidden(
) == expected_dealer_cards[i].get_hidden()
assert len(actual_player_cards) == len(expected_player_cards)
for i in range(len(actual_player_cards)):
assert actual_player_cards[i].get_suit(
) == expected_player_cards[i].get_suit()
assert actual_player_cards[i].get_pip(
) == expected_player_cards[i].get_pip()
assert actual_player_cards[i].get_hidden(
) == expected_player_cards[i].get_hidden()
def setUp(self):
self.player1 = Player('Evie')
self.player2 = Player('Amelia')
self.pg = Game()
self.pg.add_player(self.player1)
self.pg.add_player(self.player2)
self.pg.setup_game(SETTINGS_LOCATION)
def main():
display = pygame.display.set_mode(
(Config['game']['width'], Config['game']['height']))
pygame.display.set_caption(Config['game']['caption'])
game = Game(display)
game.loop()
def show_go_screen(self):
"""
This method is used upon player death to restart at the main menu.
"""
self.show_start_screen()
g = Game(c.data, c.character)
self.run(g)
def test_game_over_if_reverse_diagnol_continous_block(self):
board = TicTacBoard(3)
game = Game(board, Difficult_level.MEDIUM)
board.place_position((1, 1), "X")
board.place_position((0, 2), "X")
board.place_position((2, 0), "X")
self.assertEqual(game.is_completed_with_win(board.grid), X_WINS)
def test_player_is_type_player(self):
from src.game import Game
testGame = Game()
from src.player import Player
self.assertIsInstance(testGame.player, Player)
def main():
'''The main entry point for the game Go Fish'''
ui = UserInterface()
g = Game()
#welcom the user
auto = ui.welcome()
#deal the cards
g.deal()
ui.print_player_hand(g.player1.hand)
while not g.game_over():
if not auto:
#ask the user for a value
value = ui.request_fish()
#attempt to get the cards from the opponent
computer_transfers = g.player_turn(value)
#display the transaction to the user
ui.display(computer_transfers, g.player1_turn)
#ask the computer for a value
#and attempt to get the cards from the opponent
player_transfers = g.auto_turn()
#display the result
ui.display(player_transfers, g.player1_turn)
#print the player's hand
ui.print_player_hand(g.player1.hand)
#print the books on the table
ui.print_books(g.player1.books, g.player2.books)
#print the winner
ui.print_winner(g.tally_scores())
def test_split_status_is_set(self):
from src.game import Game
testGame = Game()
testGame.new_run()
testGame.split_player()
playerSplitStatus = testGame.player.__get_split_status__()
def test_dealer_is_type_dealer(self):
from src.game import Game
testGame = Game()
from src.dealer import Dealer
self.assertIsInstance(testGame.dealer, Dealer)
def test_deck_is_type_deck(self):
from src.game import Game
testGame = Game()
from src.deck import Deck
self.assertIsInstance(testGame.deck, Deck)
def main():
pygame.init()
display = pygame.display.set_mode((Config.game.width, Config.game.height))
pygame.display.set_caption(Config.game.caption)
game = Game(display)
game.loop()
def main():
global game
props = Properties()
props.init_props('properties.yml')
configure_log_file(props.get('log.prefix'))
logging.info('******************')
connect(props.get('db.database'),
host='mongodb://' + props.get('db.user') + ':' +
props.get('db.password') + '@' + props.get('db.host'))
logging.info('Connected to database')
logging.info('Host: %s', props.get('db.host'))
logging.info('Database: %s', props.get('db.database'))
logging.info('User: %s', props.get('db.user'))
props.load_config()
game = Game()
game_manager = GameManager()
loop = asyncio.get_event_loop()
coro = telnetlib3.create_server(port=props.get('server.port'),
log=logging.getLogger(),
shell=shell,
timeout=0)
server = loop.run_until_complete(coro)
logging.info('Server started on 127.0.0.1:' +
str(props.get('server.port')))
loop.call_later(1, game_manager.execute_timed_actions)
loop.run_until_complete(server.wait_closed())
def test_snake_eating_itself():
map = GameMap(4,4)
game = Game(map, [Position(x=1,y=2)],234)
game.print()
print(game.step(Direction.RIGHT))
game.print()
print(game.step(Direction.RIGHT))
game.print()
print(game.step(Direction.DOWN))
game.print()
print(game.step(Direction.LEFT))
game.print()
print(game.step(Direction.LEFT))
game.print()
print(game.step(Direction.LEFT))
game.print()
print(game.step(Direction.UP))
game.print()
print(game.step(Direction.UP))
game.print()
print(game.step(Direction.RIGHT))
game.print()
print(game.step(Direction.RIGHT))
game.print()
print(game.step(Direction.RIGHT))
game.print()
print(game.step(Direction.DOWN))
game.print()
print(game.step(Direction.LEFT))
game.print()
# let snake eat itself
print(game.step(Direction.UP))
game.print()
def prepare_game(cards, players=None):
if players is None:
players = ["tom", "julian"]
game = Game(TestChannel(), players, cards)
running_game = game.game_runner()
running_game.send(None)
return game, running_game
def test_game_initialization(self):
new_game = Game()
grid = new_game.grid
self.assertIsInstance(grid, list)
self.assertEqual(len(grid), 9)
for letter in grid:
self.assertIn(letter, base_letters)
def __call__(self, game_index):
print(".", end="")
game = Game(white_strategy=self.__white_strategy,
black_strategy=self.__black_strategy,
first_player=Colour(randint(0, 1)))
game.run_game(verbose=False)
return game.who_started(), game.who_won()
def setUp(self):
table = Table(200)
self.player = MartingalePlayer(table)
self.player.stake = 100
wheel = Wheel(NonRandom())
# bin_builder = BinBuilder()
# bin_builder.build_bins(wheel)
self.game = Game(wheel, table)
def setUp(self):
self.config = Fixtures.game_config
game = Game(self.config, [])
self.input_controller = GameInputController(game)
game.level.tiles[0][0].set_type('floor')
game.level.tiles[0][1].set_type('floor')
game.hero.x = 0
game.hero.y = 0
