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)
