class TestGame(unittest.TestCase): def setUp(self): self.player1 = Player('Chris', 'rock') self.player2 = Player('Edward', 'scissors') self.game = Game(self.player1, self.player2) def test_game_player(self): self.assertEqual('Edward', self.game.player2.name) self.assertEqual('rock', self.game.player1.selection) def test_game_winner_rock_vs_scissors(self): winner = self.game.check_winner(self.game) self.assertEqual('Chris', winner.name) def test_game_winner_rock_vs_paper(self): self.player3 = Player('James', 'rock') self.player4 = Player('Tim', 'paper') self.game = Game(self.player3, self.player4) winner = self.game.check_winner(self.game) self.assertEqual('Tim', winner.name) def test_game_winner_paper_vs_scissors(self): self.player1 = Player('Chris', 'paper') self.player2 = Player('Edward', 'scissors') self.game = Game(self.player1, self.player2) winner = self.game.check_winner(self.game) self.assertEqual('Edward', winner.name) def test_game_winner_draw(self): self.player1 = Player('Billy', 'paper') self.player2 = Player('Bob', 'paper') self.game = Game(self.player1, self.player2) winner = self.game.check_winner(self.game) self.assertEqual(None, winner)
def setUp(self): self.game_1 = Game("Rich", "Scott") self.game_1 = Game("Scott", "Paul") self.game_1 = Game("Paul", "Rich") self.player_1 = Player("Rich", "Rock") self.player_2 = Player("Paul", "Paper") self.player_3 = Player("Scott", "Scizzors")
class TestGame(unittest.TestCase): def setUp(self): self.player_1 = Player("Player 1", "rock") self.player_2 = Player("Player 2", "scissors") self.player_3 = Player("Player 3", "paper") self.player_4 = Player("Player 4", "paper") self.game_1 = Game(self.player_1, self.player_2) self.game_2 = Game(self.player_3, self.player_4) self.game_3 = Game(self.player_2, self.player_3) self.game_4 = Game(self.player_1, self.player_3) def test_can_find__winner_rock_scissors(self): self.assertEqual(self.player_1, self.game_1.find_winner(self.player_1, self.player_2)) def test_can_find_a_draw(self): self.assertEqual(None, self.game_2.find_winner(self.player_3, self.player_4)) def test_can_find__winner_scissors_paper(self): self.assertEqual(self.player_2, self.game_3.find_winner(self.player_2, self.player_3)) def test_can_find_winner_paper_rock(self): self.assertEqual(self.player_3, self.game_4.find_winner(self.player_1, self.player_3))
def test_computer_game(self): print("Computer Test") self.player_1 = Player("Player 1", "paper") self.player_2 = Player("Computer", "") self.game = Game(self.player_1, self.player_2) self.game.play_game(self.player_1, self.player_2) self.assertEqual("paper", self.player_1.move)
def test_game_scissors_beats_paper(self): self.player_1 = Player("Player 1", "paper") self.game = Game(self.player_1, self.player_2) self.assertEqual("paper", self.player_1.move) self.assertEqual("scissors", self.player_2.move) self.assertEqual("Player 2", self.game.play_game(self.player_1, self.player_2))
def test_game_paper_beats_rock(self): self.player_1 = Player("Player 1", "paper") self.player_2 = Player("Player 2", "rock") self.game = Game(self.player_1, self.player_2) self.assertEqual("paper", self.player_1.move) self.assertEqual("rock", self.player_2.move) self.assertEqual("Player 1", self.game.play_game(self.player_1, self.player_2))
def result(choice1, choice2): # namePlayer1 = request.form['name1'] # namePlayer2 = request.form['name2'] player_1 = Player("Player 1", choice1) player_2 = Player("Player 2", choice2) game = Game() result = game.check_winner(player_1, player_2) return render_template('result.html', result=result, title="The Winner!")
def game_success_full_attack(game: Game): game.last_action = Action( action_type=Action.ActionType.CALL_FOR_AN_ATTACK, action_data=CaptainCallForAttackData( which_captain=User(username=game.get_jr_caption()), state=State.Success, from_other_ship=False)) return game
def add_player2(): player2_name = request.form['name'] player2_selection = request.form['selector'] player2 = Player(player2_name, player2_selection) player1 = players[0] game = Game(player1, player2) winner = game.check_winner(game) return render_template('result.html', game=game, winner=winner)
def test_use_event_card_after_reveal(self, game: Game): event_card_slug = "letter-of-marque" game.event_cards = ["letter-of-marque"] player = game.turn game.players_position[player] = Positions.JR_B self._reveal_event_card_action(player, 0) self.use_event_card_action(player, event_card_slug, 0) assert game.players_position[player] in Positions.jr_positions()
def worker(): retries = 0 game_lines = [] while len(game_lines) == 0 and retries < 3: NFLScraper.fill_games() game_lines = NFLScraper.get_games_lines() retries += 1 Game.update_lines(game_lines) return jsonify(game_lines)
def play_the_game(choice_1, choice_2): draw = "It's a draw" player_1 = Player("Player 1", choice_1) player_2 = Player("Player 2", choice_2) current_game = Game(player_1, player_2) winner = current_game.get_winner(player_1, player_2) return render_template('result.html', choice_1=choice_1, choice_2=choice_2, winner=winner)
def register_token(token, user_id1, user_id2): game = Game(p1=user_id1, p2=user_id2,\ state=Game.NEW,\ createtime=datetime.utcnow(), ) db.session.add(game) db.session.commit() game.save_map(token) game.init() pass
def _setup_vote_cards(game: Game): for player_info in game.players_info.values(): if player_info.vote_cards is None: player_info.vote_cards = [] for _ in range(3): player_info.vote_cards.append( votes.generate_vote_card() ) game.vote_deck = votes.generate_vote_card() game.votes = Votes()
def return_winner(): username_1 = request.form['username1'] username_2 = request.form['username2'] selection_1 = request.form['selection1'] selection_2 = request.form['selection2'] player_1 = Player(player_1=username_1, choice_1=selection_1) player_2 = Player(player_2=username_2, choice_2=selection_2) gameresult = Game(player_1, player_2) result = gameresult.reveal_winner(player_1, player_2) return render_template('/', result=result)
def test_reveal_eight_bells(self, game: Game): player = game.turn position = game.get_position(player) # since it's random we test until we get the result! while game.get_position(player) == position: player = game.turn position = game.get_position(player) game.event_cards = ["eight-bells"] self._reveal_event_card_action(player, 0) assert game.get_position(player) != position
class GameTest(unittest.TestCase): def setUp(self): self.game_1 = Game(Player("Hal", "Rock"), Player("Dave", "Scissors")) self.game_2 = Game(Player("Rick", "Rock"), Player("Morty", "Scissors")) self.game_3 = Game(Player("Bill", "Paper"), Player("Ted", "Paper")) self.game_4 = Game(Player("Merry", "Rock"), Player("Pippin", "Paper")) self.game_5 = Game(Player("Bob", "Rock"), ) def test_game_has_player_1(self): self.assertEqual("Hal", self.game_1.player_1.name) def test_game_has_player_2(self): self.assertEqual(3, self.game_1.player_2.choice) def test_game_can_play__player_1_win(self): self.assertEqual("Rick", self.game_2.play().name) def test_game_can_play__player_2_win(self): self.assertEqual("Paper", self.game_4.play().input_choice) def test_game_can_play__tied_game(self): self.assertEqual(None, self.game_3.play()) def test_show_results__winner(self): self.game_1.play() self.assertEqual("Hal wins by playing Rock!", self.game_1.show_results()) def test_show_results__draw(self): self.game_3.play() self.assertEqual("It's a draw!", self.game_3.show_results()) def test_game_gets_computer_player(self): self.assertEqual("Computer", self.game_5.player_2.name)
def game_result_comp(p1_choice, p2_choice): game = Game(player_1, computer_player) game_result = game.determine_winner(player_1, computer_player) return render_template('comp_playagain.html', title="Play again!", player_1=player_1, player_2=computer_player, game_result=game_result, p1_score=player_1.score, p2_score=computer_player.score, results=player_1.results)
def game_result(p1_choice, p2_choice): game = Game(player_1, player_2) game_result = game.determine_winner(player_1, player_2) return render_template('playagain.html', title="Play again!", player_1=player_1, player_2=player_2, game_result=game_result, p1_score=player_1.score, p2_score=player_2.score, results=player_1.results)
def test_reveal_fountain_of_youth_dodge_maroon(self, game: Game): player = game.turn game.event_cards = ["fountain-of-youth"] self._reveal_event_card_action(player, 0) self._keep_event_card_action(player) response = self._get_my_game(player).json() assert (response["gameStatus"]["playerGameInfo"]["eventCards"][0] ["eventCard"]["slug"] == "fountain-of-youth") player_position = game.get_position(player) game.maroon_player(player) assert game.get_position(player) == player_position
def __init__(self, output: str): """Class initialization.""" self.game = Game() if output == "cli": self.view = CLIView(self.game) self.controller = CLIController(self.game) elif output == "pygame": self.view = PygameView(self.game) self.controller = PygameController(self.game)
def solo_play(): player_1 = request.form['player_1'] choice_1 = request.form['choice_1'] game = Game(Player(player_1, choice_1), ) winning_player = game.play() result = game.show_results() return render_template("results.html", title="Results", winning_player=winning_player, game_result=result)
def test_generate_computer_player(self): player_1 = Player("Owl", "scissors") player_2 = Player("The Computer", None) self.game = Game(player_1, player_2) self.game.generate_computer_player(player_2) self.assertIsNotNone(player_2.choice)
def play_the_computer(): player = Player(request.form["name"], request.form["move"]) move_list = ["rock", "paper", "scissors"] computer = Player("SUPER COMPUTER", random.choice(move_list)) game = Game(player, computer) winner = game.play_rock_paper_scissors() return render_template("play_the_computer.html", title="Game vs. Computer Results", player_1=player.name, player_2=computer.name, move1=player.hand, move2=computer.hand, winner=winner)
def createPC(): player1_name = request.form["name1"] player1_choice = request.form["choice1"] player1 = Player(player1_name, player1_choice) game = Game("RPS") game.add_player(player1) pc_player = game.pc_player() game.add_player(pc_player) result = game.game_result(player1, pc_player, player1.choice, pc_player.choice) game.add_result(result) print(pc_player) return redirect('/playpc')
def play_route(choice1, choice2): player_1 = Player("Player 1", choice1) player_2 = Player("Player 2", choice2) game = Game(player_1, player_2) winner = game.play_rock_paper_scissors() return render_template("result.html", title="Results", player_1=player_1.name, player_2=player_2.name, choice1=choice1, choice2=choice2, winner=winner)
def game_result(): form_data = request.form player_1 = Player(form_data['player_1_name'], form_data['player_1_choice']) if form_data['computer'] == '1': player_2 = Player("Computer", "") player_2.computer() else: player_2 = Player(form_data['player_2_name'], form_data['player_2_choice']) r_p_s = Game("Rock Paper Scissors", player_1, player_2) r_p_s.play() return render_template('result.html', game=r_p_s)
def test_two_players_with_albatross(self, game: Game): game.event_cards = ["albatross", "albatross"] player1 = game.turn self._reveal_event_card_action(player1, 0) self._keep_event_card_action(player1) while game.get_position(game.turn) not in Positions.jr_positions(): game.next_turn() player2 = game.turn self._reveal_event_card_action(player2, 0) self._keep_event_card_action(player2) response = self._get_my_game(player2).json() assert (response["gameStatus"]["playersPosition"][player1] in Positions.tr_positions()) assert (response["gameStatus"]["playersPosition"][player2] in Positions.tr_positions())
def play_game(hand1, hand2): player_1 = Player("Player 1", hand1) player_2 = Player("Player 2", hand2) game = Game(player_1, player_2) result = f"Player 1 had {hand1} and player 2 had {hand2}. " if game.check_winner(): result += "The winner is player 1" elif game.check_winner() == None: result += "It is a DRAW!" else: result += "The winner is player 2" return render_template('result.html', title="Result", result=result)
def result(choice1, choice2): global player_1_name global player_2_name player_1 = Player(player_1_name, choice1) player_2 = Player(player_2_name, choice2) new_result, new_winner = Game.game_result(player_1, player_2) return render_template('result.html', result=new_result, winner=new_winner)
def prepare(token): output = None conf_load(True) cur_game = Game.get_by_token(token) if cur_game and cur_game.participate(g.user) \ and cur_game.get_attr('state') == cur_game.NEW: #and cur_game.state == cur_game.NEW: cur_game.state = cur_game.PLAYING cur_game.lock() waiting = cur_game.pop_waiting() if waiting: rounds = Rounds.get_rounds(conf('rounds_init')) cur_game.prepare(conf('score_init'), rounds) output = cur_game.new_round() if output.get("type") != 'done': output["type"] = 'new' cur_game.notice(output) cur_game.unlock() else: try: output = cur_game.declare_and_wait(g.user.id, conf('prepare_timeout')) except TimeoutError: output = cur_game.timeout() else: output = {"type": "exit",} output['state'] = 'new' return create_response(cur_game, output)
class TestGame(unittest.TestCase): def setUp(self): self.player1 = Player("Lobster Queen", "Rock") self.player2 = Player("Lobster King", "Scissors") self.game = Game(self.player1, self.player2) # @unittest.skip("Delete this line to run the test") def test_add_players(self): self.game.add_players(self.player1) self.game.add_players(self.player2) self.assertEqual(2, self.game.check_players()) # @unittest.skip("Delete this line to run the test") def test_play_game(self): self.assertEqual(self.player1.name, self.game.play_game(self.player1, self.player2))
def hand_in(token): cur_game = Game.get_by_token(token) if not cur_game or not cur_game.participate(g.user)\ or cur_game.get_attr('state') != cur_game.PLAYING: #or cur_game.state != cur_game.PLAYING: if cur_game: print cur_game.state abort(400) data = request.get_json() if not data: abort(400) if data['type'] == 'timeout': handin = { "timeout": True, 'time':conf('total_time'), 'action':Log.create_action(g.user.id,'TIMEOUT')} else: handin = { "timeout": False, "time": data['time'], "choice": data['choice'], 'action':Log.create_action( g.user.id, 'NORMAL', data['choice'], data['time']) } cur_game.lock() actions = [handin['action']] mate = cur_game.pop_waiting() ack = None if mate: actions = [handin['action'],mate['action']] if handin['timeout'] or mate['timeout']: #cur_game.update_score("timeout") ack = cur_game.new_round() if ack.get("type") != 'done': ack['type'] = 'timeout' else: time = max(handin['time'], mate['time']) state = 'fail' if mate['choice'] == handin['choice']: state = 'match' #cur_game.update_score(state, time) ack = cur_game.new_round() ack['state'] = state if ack.get("type") != 'done': ack['type'] = state #else: # ack = { "type": "unmatch" } # count = cur_game.get_attr('submit_count') # count += 1 #cur_game.set_attr('submit_count', count) cur_game.notice(ack) cur_game.unlock() else: try: wait_time = conf('timeout_time') wait_time += conf('total_time')-handin['time'] ack = cur_game.declare_and_wait(handin,wait_time) except TimeoutError: ack = cur_game.timeout() ack['state'] = 'exit' ack['time'] = handin['time'] return create_response(cur_game, ack,actions)