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")
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 setUp(self):
self.player_1 = Player("Dave", "scissors")
self.player_2 = Player("Laura", "paper")
self.player_3 = Player("Chiara", "rock")
self.player_4 = Player("Wayne", "rock")
self.game1 = Game(self.player_1, self.player_2)
self.game2 = Game(self.player_1, self.player_3)
self.game3 = Game(self.player_2, self.player_3)
self.game4 = Game(self.player_3, self.player_4)
def get_games_results(game_name: str, web: str = "all"):
"""
Get games results from spiders
:param game_name:
:param web:
:return: list of games, obtained from spiders.
"""
games = []
not_formatted_games = []
time.sleep(get_random_delay())
if web == "eneba":
not_formatted_games.extend(EnebaScrapper(game_name).get_content())
elif web == "instantgaming":
not_formatted_games.extend(
InstantGamingScrapper(game_name).get_content())
elif web == "steam":
not_formatted_games.extend(SteamScrapper(game_name).get_content())
elif web == "all":
not_formatted_games.extend(EnebaScrapper(game_name).get_content())
time.sleep(get_random_delay())
not_formatted_games.extend(
InstantGamingScrapper(game_name).get_content())
time.sleep(get_random_delay())
not_formatted_games.extend(SteamScrapper(game_name).get_content())
for game in not_formatted_games:
if game:
games.append(
Game(title=game.get("title"),
price=game.get("price"),
link=game.get("link"),
search=game_name))
return games
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 parse_match_playing(blob):
# MatchGameRoomStateType_Playing
import app.mtga_app as mtga_app
temp_players = {1: {}, 2: {}}
match_id = blob['matchGameRoomStateChangedEvent']['gameRoomInfo'][
'gameRoomConfig']['matchId']
game_room_info = blob["matchGameRoomStateChangedEvent"]["gameRoomInfo"]
game_room_players = game_room_info["players"]
for player in game_room_players:
temp_players[player["systemSeatId"]]["player_id"] = player["userId"]
game_room_config = game_room_info["gameRoomConfig"]
reserved_players = game_room_config["reservedPlayers"]
for player in reserved_players:
temp_players[player["systemSeatId"]]["name"] = player["playerName"]
match_config = game_room_config["matchConfig"]
if "teams" in match_config:
teams = match_config["teams"]
for team in teams:
players = team["players"]
for player in players:
player_seat = player["systemSeatId"]
temp_players[player_seat]["deck"] = util.card_ids_to_card_list(
player["deckCards"])
for player_idx in [1, 2]:
if "deck" not in temp_players[player_idx]:
temp_players[player_idx]["deck"] = []
# set up shared zones
shared_battlefield = Zone("battlefield")
shared_exile = Zone("exile")
shared_limbo = Zone("limbo")
shared_stack = Zone("stack")
player1 = Player(temp_players[1]["name"], temp_players[1]["player_id"], 1,
shared_battlefield, shared_exile, shared_limbo,
shared_stack, temp_players[1]["deck"])
player2 = Player(temp_players[2]["name"], temp_players[2]["player_id"], 2,
shared_battlefield, shared_exile, shared_limbo,
shared_stack, temp_players[2]["deck"])
with mtga_app.mtga_watch_app.game_lock:
if mtga_app.mtga_watch_app.player_id == player1.player_id:
hero = player1
opponent = player2
elif mtga_app.mtga_watch_app.player_id == player2.player_id:
hero = player2
opponent = player1
else:
raise Exception(
"Don't know who hero is: player_id: {} / player 1: {} / player 2: {}"
.format(mtga_app.mtga_watch_app.player_id, player1.player_id,
player2.player_id))
hero.is_hero = True
if mtga_app.mtga_watch_app.intend_to_join_game_with:
hero.original_deck = mtga_app.mtga_watch_app.intend_to_join_game_with
mtga_app.mtga_watch_app.game = Game(match_id, hero, opponent,
shared_battlefield, shared_exile,
shared_limbo, shared_stack)
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 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 add_player1():
player1_name = request.form['name']
player1_selection = request.form['selector']
player1 = Player(player1_name, player1_selection)
add_player(player1)
player2 = Player('place', 'holder')
game = Game(player1, player2)
return render_template('add_player1.html', game=game)
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 test_game_player2_win(self):
self.game1 = Game("Our first game",\
Player("Sauron", "scissors"),\
Player("Gandalf", "rock"))
self.game1.play()
self.assertEqual(self.game1._result, "Gandalf won the game")
self.game2 = Game("Our first game",\
Player("Sauron", "rock"),\
Player("Gandalf", "paper"))
self.game2.play()
self.assertEqual(self.game2._result, "Gandalf won the game")
self.game3 = Game("Our first game",\
Player("Sauron", "paper"),\
Player("Gandalf", "scissors"))
self.game3.play()
self.assertEqual(self.game3._result, "Gandalf won the game")
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 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 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 __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 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 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 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 play_rps_cpu():
player1 = Player(request.form['player1'], request.form['choice1'])
player2 = Player('Computer', (["rock","paper","scissors"])[randrange(0, 3)])
game = Game(player1, player2)
reply = game.play_new_game(player1, player2)
# RPS Image CSS properties
cp1 = game.clip_path(player1)
ml1 = game.margin_left(player1)
mt1 = game.margin_top(player1)
cp2 = game.clip_path(player2)
ml2 = game.margin_left(player2)
mt2 = game.margin_top(player2)
return render_template('play-cpu.html', reply=reply, cp1=cp1, ml1=ml1, mt1=mt1, cp2=cp2, ml2=ml2, mt2=mt2)
def play_rps():
player1 = Player(request.form['player1'], request.form['choice1'])
player2 = Player(request.form['player2'], request.form['choice2'])
game = Game(player1, player2)
reply = game.play_new_game(player1, player2)
# RPS Image CSS properties
cp1 = game.clip_path(player1)
ml1 = game.margin_left(player1)
mt1 = game.margin_top(player1)
cp2 = game.clip_path(player2)
ml2 = game.margin_left(player2)
mt2 = game.margin_top(player2)
return render_template('index.html', reply=reply, cp1=cp1, ml1=ml1, mt1=mt1, cp2=cp2, ml2=ml2, mt2=mt2)
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 create():
player1_name = request.form["name1"]
player1_choice = request.form["choice1"]
player2_name = request.form["name2"]
player2_choice = request.form["choice2"]
player1 = Player(player1_name, player1_choice)
player2 = Player(player2_name, player2_choice)
game = Game("RPS")
game.add_player(player1)
game.add_player(player2)
result = game.game_result(player1, player2, player1.choice, player2.choice)
game.add_result(result)
return redirect('/play')
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 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 one_player():
# create game
game1 = Game()
# create player one (human)
p1name = request.form["p1-name"]
p1move = request.form["p1-move"]
player1 = Player(p1name,p1move)
# create player two (Computer)
player2 = game1.cpu_player()
# add players to game
game1.add_player(player1)
game1.add_player(player2)
# find winner
winner = game1.find_winner()
return render_template("result.html",title="FIGHT OVER",winner=winner,game=game1)
def two_player():
# create player 1
p1name = request.form["p1-name"]
p1choice = request.form["p1-move"]
player1 = Player(p1name,p1choice)
# Create player 2
p2name = request.form["p2-name"]
p2choice = request.form["p2-move"]
player2 = Player(p2name,p2choice)
# create game and add players
game1 = Game()
game1.add_player(player1)
game1.add_player(player2)
# find winner
winner = game1.find_winner()
return render_template("result.html",title="FIGHT OVER",winner=winner,game=game1)
def index(player_1_name, player_1_guess, player_2_name, player_2_guess):
# # player_1
player_1 = Player(player_1_name, player_1_guess)
player_2 = Player(player_2_name, player_2_guess)
the_game = Game()
result = the_game.play(player_1, player_2)
return render_template("index.html", result=result, title="Skies")
#@app.route('/rock/rock') # so flask returns rock/rock and the return function to the server?
#def draw():
# return "Its a draw"
#@app.route('/rock/paper') #test inputs are made in html as python code?
#def rock_wins():
# return "rock wins"
