def test_lower_trump_is_allowed_if_no_other_cards_are_in_hand(
self) -> None:
players = [Player(), Player(), Player(), Player()]
players[0].hand = {Card(suit=Suit.HEARTS, rank=Rank.KING)}
players[1].hand = {Card(suit=Suit.DIAMONDS, rank=Rank.ACE)}
players[2].hand = {
Card(suit=Suit.DIAMONDS, rank=Rank.TEN),
Card(suit=Suit.DIAMONDS, rank=Rank.KING),
Card(suit=Suit.DIAMONDS, rank=Rank.QUEEN),
Card(suit=Suit.DIAMONDS, rank=Rank.EIGHT),
Card(suit=Suit.DIAMONDS, rank=Rank.SEVEN),
}
deal = Deal(players=players, bidder_index=0, trump_suit=Suit.DIAMONDS)
trick = Trick(deal=deal, leading_player_index=0)
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
trick.play(Card(suit=Suit.DIAMONDS, rank=Rank.ACE))
self.assertEqual(
{
Card(suit=Suit.DIAMONDS, rank=Rank.TEN),
Card(suit=Suit.DIAMONDS, rank=Rank.KING),
Card(suit=Suit.DIAMONDS, rank=Rank.QUEEN),
Card(suit=Suit.DIAMONDS, rank=Rank.EIGHT),
Card(suit=Suit.DIAMONDS, rank=Rank.SEVEN),
},
trick.legal_cards,
)
def test_cards_can_be_compared_before_a_suit_is_led(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
# The queen should be consider higher, as we are assuming we are not
# dealing with a trump suit, given that no trump suit was even specified yet.
self.assertEqual(
1,
trick.compare_cards(Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN)))
# Unrelated cards cannot be compared properly without a trump suit or a led suit.
self.assertEqual(
0,
trick.compare_cards(
Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.SPADES, rank=Rank.ACE),
))
deal.trump_suit = Suit.HEARTS
# Now that we have a trump suit defined, the higher trump should rank higher.
self.assertEqual(
-1,
trick.compare_cards(Card(suit=Suit.HEARTS, rank=Rank.JACK),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN)))
def process_players():#This method sets up players in the database so that their scores can be tracked
if request.method == 'POST':
player_1_Name = request.form['player1']
player_2_Name = request.form['player2']
player_3_Name = request.form['player3']
player_4_Name = request.form['player4']
tournament_Name = request.form['tournament_name']
if (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == None or (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == "" or (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == False:
flash('No blank names allowed, please input 4 player names.')
return redirect('/initiate_tournament?p1='+player_1_Name+'&p2='+player_2_Name+'&p3='+player_3_Name+'&p4='+player_4_Name+'&tname='+tournament_Name)
else:#This adds a tournament and players to the database
logged_in_user_id = User.query.filter_by(email=session['user']).first().id
db.session.add(Tournament(logged_in_user_id, tournament_Name))
db.session.commit()
session['tournament_Id'] = Tournament.query.filter_by(name=tournament_Name).first().id
db.session.add(Player(player_1_Name,session['tournament_Id'],logged_in_user_id))#Players are instatiated using player name from template POST request and tournament_ID session variable
db.session.add(Player(player_2_Name,session['tournament_Id'],logged_in_user_id))
db.session.add(Player(player_3_Name,session['tournament_Id'],logged_in_user_id))
db.session.add(Player(player_4_Name,session['tournament_Id'],logged_in_user_id))
db.session.commit()
#After players have been confirmed in the DB, their name is assigned into Session variables
player_1_Id = Player.query.filter_by(name = player_1_Name , owner_id = logged_in_user_id).first().id
player_2_Id = Player.query.filter_by(name = player_2_Name , owner_id = logged_in_user_id).first().id
player_3_Id = Player.query.filter_by(name = player_3_Name , owner_id = logged_in_user_id).first().id
player_4_Id = Player.query.filter_by(name = player_4_Name , owner_id = logged_in_user_id).first().id
session['player_1_Id'] = player_1_Id
session['player_2_Id'] = player_2_Id
session['player_3_Id'] = player_3_Id
session['player_4_Id'] = player_4_Id
return redirect('/score_input')
def test_a_player_must_follow_suit_if_possible(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.ACE)}
players[1].hand = {
Card(suit=Suit.SPADES, rank=Rank.KING),
Card(suit=Suit.SPADES, rank=Rank.QUEEN),
Card(suit=Suit.HEARTS, rank=Rank.KING),
}
trick.play(Card(suit=Suit.SPADES, rank=Rank.ACE))
# The first player has led spades; the next player should have two legal choices.
self.assertEqual(
{
Card(suit=Suit.SPADES, rank=Rank.KING),
Card(suit=Suit.SPADES, rank=Rank.QUEEN),
}, trick.legal_cards)
self.assertEqual(
True,
Card(suit=Suit.HEARTS, rank=Rank.KING)
in deal.players[trick.player_index_to_play].hand)
# If the player attempts to play a different card anyway, then despite holding the card
# in their hand, it should raise an exception.
self.assertRaises(AssertionError, trick.play,
Card(suit=Suit.HEARTS, rank=Rank.KING))
def test_a_player_must_not_follow_suit_if_not_possible(self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.ACE)}
players[1].hand = {
Card(suit=Suit.HEARTS, rank=Rank.KING),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN),
Card(suit=Suit.DIAMONDS, rank=Rank.KING),
}
trick.play(Card(suit=Suit.SPADES, rank=Rank.ACE))
# The next player may play any of these cards despite them not following suit.
self.assertEqual(
{
Card(suit=Suit.HEARTS, rank=Rank.KING),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN),
Card(suit=Suit.DIAMONDS, rank=Rank.KING),
},
trick.legal_cards,
)
# Playing this card should be acceptable despite it not following suit.
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
def init_dev_data():
"""Initializes database with data for development and testing"""
db.drop_all()
db.create_all()
print("Initialized Connect 4 Database.")
ga = Game()
db.session.add(ga)
p1 = Player(username="******",
birthday=datetime.datetime.strptime('11/06/1991',
'%m/%d/%Y').date(),
pw_hash=generate_password_hash("tow"))
p2 = Player(username="******",
birthday=datetime.datetime.strptime('01/14/1987',
'%m/%d/%Y').date(),
pw_hash=generate_password_hash("twaits"))
db.session.add(p1)
print("Created %s" % p1.username)
db.session.add(p2)
print("Created %s" % p2.username)
ga.player_one = p1
ga.player_two = p2
db.session.commit()
print("Added dummy data.")
def start_game():
os.system('cls' if os.name == 'nt' else 'clear')
print('\nHello my friend! Let\'s play a game!')
field = Field('new')
print(
'So, to play a game you need to call your friend and say me your names!\n'
)
p1_name = input('Tell me the name of the first player: ')
p2_name = input('Tell me the name of the second player: ')
player1 = Player(p1_name, 1)
player2 = Player(p2_name, 1)
os.system('cls' if os.name == 'nt' else 'clear')
# turn = get_turn(player1,player2)
print(
'\nNow it\'s time to place your ships on a game field! And the first player will be {}\n'
.format(player1.name))
os.system('cls' if os.name == 'nt' else 'clear')
#field.print_field('')
p1_ships = create_ships(field)
os.system('cls' if os.name == 'nt' else 'clear')
print(
'\nNow it\'s time to place its ships For the second player {}'.format(
player2.name))
input('\n\npress Enter to continue...')
os.system('cls' if os.name == 'nt' else 'clear')
field.print_field('')
p2_ships = create_ships(field)
def game_init():
chess = GameField()
modes = (1, 2, 3)
mode = 9
while mode not in modes:
mode = int(
input(
'Choose mode of the game: \n1: human vs human\n2: computer vs human\n3: computer vs computer \n: '
))
if mode == 1:
name1 = input('Input name of first (white) player: ')
name2 = input('Input name of second (black) player: ')
white_player = Player(name1, 'white', chess)
black_player = Player(name2, 'black', chess)
elif mode == 2:
name1 = input('Input name of first (white) player: ')
name2 = input('Input name of second (black) player (computer): ')
white_player = Player(name1, 'white', chess)
black_player = Computer(name2, 'black', chess)
else:
name1 = input('Input name of first (white) player (computer): ')
name2 = input('Input name of second (black) player (computer): ')
white_player = Computer(name1, 'white', chess)
black_player = Computer(name2, 'black', chess)
return chess, white_player, black_player
def init_db():
Base.metadata.create_all(bind=engine)
player1 = Player(name="player1")
db_session.add(player1)
sc = Score(rule='ガチヤグラ',
power=1900,
weapon='スクリュースロッシャー',
result='WIN',
player=player1)
db_session.add(sc)
sc = Score(rule='ガチエリア',
power=1920,
weapon='スクリュースロッシャー',
result='WIN',
player=player1)
db_session.add(sc)
player2 = Player(name="player2")
sc = Score(rule='ガチアサリ',
power=2100,
weapon='スプラシューター',
result='WIN',
player=player2)
db_session.add(sc)
sc = Score(rule='ガチエリア',
power=2320,
weapon='スプラシューターベッチュー',
result='WIN',
player=player2)
db_session.add(sc)
db_session.commit()
def check_conditions(self):
for event in pygame.event.get():
self.gui_manager.process_events(event)
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
return "select_player"
elif event.key == K_RETURN:
inp = self.text_box.get_text()
if len(inp) > 0:
new_player = Player(name=inp)
GameApp.session.add(new_player)
return "select_player"
else:
return None
elif event.type == pygame.USEREVENT:
if event.user_type == pygame_gui.UI_BUTTON_PRESSED:
if event.ui_element == self.cancel_button:
return "select_player"
elif event.ui_element == self.save_button:
inp = self.text_box.get_text()
if len(inp) > 0:
new_player = Player(name=inp)
GameApp.session.add(new_player)
return "select_player"
else:
return None
def test_overtrumping_the_opponent_is_mandatory_if_teammate_is_not_leading(
self) -> None:
players = [Player(), Player(), Player(), Player()]
players[0].hand = {Card(suit=Suit.HEARTS, rank=Rank.KING)}
players[1].hand = {Card(suit=Suit.DIAMONDS, rank=Rank.TEN)}
players[2].hand = {Card(suit=Suit.SPADES, rank=Rank.QUEEN)}
players[3].hand = {
Card(suit=Suit.DIAMONDS, rank=Rank.ACE),
Card(suit=Suit.SPADES, rank=Rank.EIGHT),
Card(suit=Suit.SPADES, rank=Rank.JACK),
}
deal = Deal(players=players,
bidder_index=0,
trump_suit=Suit.SPADES,
rules=RuleSet.ROTTERDAM)
trick = Trick(deal=deal, leading_player_index=0)
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
trick.play(Card(suit=Suit.DIAMONDS, rank=Rank.TEN))
trick.play(Card(suit=Suit.SPADES, rank=Rank.QUEEN))
self.assertEqual({
Card(suit=Suit.SPADES, rank=Rank.JACK),
}, trick.legal_cards)
# No matter whether this game is Rotterdam or Amsterdam style, the trump is the only legitimate option.
deal.rules = RuleSet.AMSTERDAM
self.assertEqual({
Card(suit=Suit.SPADES, rank=Rank.JACK),
}, trick.legal_cards)
def test_overtrumping_your_teammate_is_still_mandatory_in_amsterdam_deals_if_it_is_the_led_suit(
self) -> None:
players = [Player(), Player(), Player(), Player()]
players[0].hand = {Card(suit=Suit.HEARTS, rank=Rank.KING)}
players[1].hand = {Card(suit=Suit.SPADES, rank=Rank.TEN)}
players[2].hand = {
Card(suit=Suit.HEARTS, rank=Rank.NINE),
Card(suit=Suit.HEARTS, rank=Rank.QUEEN),
Card(suit=Suit.DIAMONDS, rank=Rank.ACE),
}
deal = Deal(players=players,
bidder_index=0,
trump_suit=Suit.HEARTS,
rules=RuleSet.ROTTERDAM)
trick = Trick(deal=deal, leading_player_index=0)
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
trick.play(Card(suit=Suit.SPADES, rank=Rank.TEN))
# Despite the fact that the teammate is leading the trick so far, playing a lower trump
# or any other card is not allowed: when following suit in trump, over-trumping is still
# mandatory.
self.assertEqual({
Card(suit=Suit.HEARTS, rank=Rank.NINE),
}, trick.legal_cards)
def test_overtrumping_your_teammate_is_not_mandatory_in_amsterdam_deals_if_teammate_is_winning(
self) -> None:
players = [Player(), Player(), Player(), Player()]
players[0].hand = {Card(suit=Suit.HEARTS, rank=Rank.KING)}
players[1].hand = {Card(suit=Suit.SPADES, rank=Rank.TEN)}
players[2].hand = {Card(suit=Suit.HEARTS, rank=Rank.NINE)}
players[3].hand = {
Card(suit=Suit.DIAMONDS, rank=Rank.ACE),
Card(suit=Suit.SPADES, rank=Rank.EIGHT),
Card(suit=Suit.SPADES, rank=Rank.JACK),
}
deal = Deal(players=players,
bidder_index=0,
trump_suit=Suit.SPADES,
rules=RuleSet.AMSTERDAM)
trick = Trick(deal=deal, leading_player_index=0)
trick.play(Card(suit=Suit.HEARTS, rank=Rank.KING))
trick.play(Card(suit=Suit.SPADES, rank=Rank.TEN))
trick.play(Card(suit=Suit.HEARTS, rank=Rank.NINE))
# Playing a higher trump is legal, but not necessary. The player may also drop the ace.
# Note however that playing a lower trump is still illegal.
self.assertEqual(
{
Card(suit=Suit.DIAMONDS, rank=Rank.ACE),
Card(suit=Suit.SPADES, rank=Rank.JACK),
}, trick.legal_cards)
# In an Amsterdam deal, the player is forced to play the higher trump card.
deal.rules = RuleSet.ROTTERDAM
self.assertEqual({
Card(suit=Suit.SPADES, rank=Rank.JACK),
}, trick.legal_cards)
def main():
player1 = Player('Jekyll')
player2 = Player('Hyde')
try:
gameEngine = GameEngine(2, GameType.value_match)
gameEngine.play((player1, player2))
except SnapException as ex:
print ex
def addPlayer(game_id, mdn, player_alias):
newPlayer = Player()
newPlayer = Player(game_id, mdn, 0, player_alias)
db.session.add(newPlayer)
db.session.commit()
new_player = db.session.query(Player).filter(Player.mdn == mdn).first()
#db.session.close()
return new_player.id
def play_bad_card() -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0)
trick = Trick(deal=deal, leading_player_index=0)
players[0].hand = {Card(suit=Suit.SPADES, rank=Rank.ACE)}
# The player does not actually have this card; it should throw AssertionError
trick.play(Card(suit=Suit.HEARTS, rank=Rank.ACE))
def test_winning_card_detection_returns_none_if_no_card_was_played(
self) -> None:
players = [Player(), Player(), Player(), Player()]
deal = Deal(players=players, bidder_index=0, trump_suit=Suit.DIAMONDS)
trick = Trick(deal=deal, leading_player_index=0)
self.assertEqual(None, trick.winning_card)
self.assertEqual(None, trick.winning_card_index)
def players():
conn, cursor = db.connect()
p1 = Player(test_user_id, "erlend", 1000)
p2 = Player(pingpongbot_id, "pingpong", 1000)
db.create_player(cursor, p1)
db.create_player(cursor, p2)
conn.commit()
conn.close()
yield p1, p2
def test_multiple_players(self):
import copy
player1 = Player("player1")
player2 = Player("player2")
service = GameService(10, 10, 5, [player1, player2])
service.add_player_to_game([player2])
service.set_board()
#All players should share the same initial game board
self.assertEqual(service._game._current_player, player2)
def delete(self, gid, pid):
game = Game(gid)
owner = game.get_owner()
player = Player(gid, pid)
user = player.get_user()
auth = request.authorization
if not (authorize(auth, owner) or authorize(auth, user)):
return auth_response()
Player(gid, pid).delete()
return '', 204
def test_a_deck_cannot_be_dealt_if_not_evenly(self) -> None:
deck = Deck()
players = [Player(), Player(), Player()]
# What we are testing is the scenario where the deck's cards cannot
# be dealt evenly among the players, so we must assert it.
self.assertNotEqual(len(deck.cards) % len(players), 0)
# In this scenario, the method should throw a ValueError.
self.assertRaises(ValueError, deck.deal, players)
def test_a_deck_can_be_dealt(self) -> None:
deck = Deck()
players = [Player(), Player(), Player(), Player()]
deck.deal(players)
# The deck is fully depleted
self.assertEqual(0, len(deck.cards))
for player in players:
# Each player has the required amount of cards
self.assertEqual(8, len(player.hand))
def main():
RpsGame.print_header()
name = get_player_name()
player1 = Player(name)
player2 = Player('Computer')
game = RpsGame(player1, player2)
game.start()
def test_a_deal_asks_for_trump_suit_when_started(self) -> None:
players = [Player(), Player(), Player(), Player()]
suit_identifier: str
suit: Suit
for (suit_identifier, suit) in Suit.suits().items():
with patch("builtins.input", return_value=suit_identifier):
deal = Deal(players=players, bidder_index=0)
deal.initialize()
self.assertEqual(deal.trump_suit, suit)
def setUp(self):
self.player_one = Player("Gosho", 50, 2, 16)
self.player_two = Player("Misho", 50, 2, 16)
self.player_three = Player("Misho", 20, 2, 16)
self.player_four = Player("Misho", 0, 2, 16)
self.cards = [GoodCard(), BadCard(), TripCard()]
self.field = [[{
1: Cell(0, 0, self.cards)
}, {
2: Cell(0, 1, self.cards)
}]]
self.levels = {"SMALL": (1, 2), "MEDIUM": (2, 3), "LARGE": (3, 4)}
def setUp(self):
# set up the test DB
self.db = tested_db
self.db.create_all()
self.db.session.add(City(id=1, city_name="montreal", country="canada"))
self.db.session.add(Team(id=2, team_name="canadiens", association="east", division="atlantic", city_id=1))
self.db.session.add(Player(id=1, name="Maurice Richard", team_id=1))
self.db.session.add(Player(id=2, name="PK Subban", team_id=1))
self.db.session.add(Player(id=3, name="Paul Byron", team_id=1))
self.db.session.commit()
self.app = tested_app.test_client()
def main():
# デッキを作成
deck = Deck()
card_nums = [
'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K',
'Joker'
]
card_ranks = [12, 13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14]
card_suits = ['spade', 'heart', 'diamond', 'club']
card_mapping = {}
for (num, rank) in zip(card_nums, card_ranks):
card_mapping[num] = rank
for rank in card_ranks[:13]: # デッキにJoker含むカード54枚を加える
for suit in card_suits:
card = Card(suit=suit, rank=rank)
deck.cards.append(card)
deck.cards.append(Card(suit='*', rank=card_mapping['Joker']))
deck.cards.append(Card(suit='*', rank=card_mapping['Joker']))
# print(len(deck.cards))
# for card in deck.cards:
# print(card)
# プレイヤー追加と初期設定
player1 = Player(name='player1')
player2 = Player(name='player2')
player1.doubt_pct = 0.35
player2.doubt_pct = 0.2
# 20ゲーム x 50回試行する
result_p1 = []
for j in range(10):
datum = []
for i in range(20):
data = play_game(player1, player2, deck)
datum.append([data[0].name, data[1]])
print('-' * 100)
print('-' * 100)
print('-' * 100)
# スコアを集計
p1_score, p2_score = utils.calc_data(datum)
result_p1.append(p1_score)
print('player1のスコア: {} \nplayer2のスコア: {}'.format(p1_score, p2_score))
df = pd.DataFrame(data=result_p1, columns=['score'])
print('##' * 50)
print('合計: {} \n平均: {} \n分散: {}'.format(df['score'].sum(),
df['score'].mean(),
df['score'].var()))
df.plot()
plt.show()
def setup(self):
num_players = int(input('Num Players: '))
for i in range(num_players):
player = Player(name='Player %d' % (i + 1))
self.players.append(player)
self.analyzer = GameStatusAnalyzer(players=self.players)
# Set the hidden state of the game
from random import randint as r
suspects = SUSPECTS.copy()
weapons = WEAPONS.copy()
rooms = ROOMS.copy()
# Create solution
solution = {
CardType.SUSPECT: suspects.pop(r(0,
len(suspects) - 1)),
CardType.WEAPON: weapons.pop(r(0,
len(weapons) - 1)),
CardType.ROOM: rooms.pop(r(0,
len(rooms) - 1)),
}
self.solution = solution
# Deal hands
hidden_players = [
Player('hidden ' + str(i + 1)) for i in range(num_players)
]
while len(suspects) > 0:
player = hidden_players[r(0, len(hidden_players) - 1)]
card = suspects.pop(r(0, len(suspects) - 1))
player.known_cards[CardType.SUSPECT].append(card)
while len(weapons) > 0:
player = hidden_players[r(0, len(hidden_players) - 1)]
card = weapons.pop(r(0, len(weapons) - 1))
player.known_cards[CardType.WEAPON].append(card)
while len(rooms) > 0:
player = hidden_players[r(0, len(hidden_players) - 1)]
card = rooms.pop(r(0, len(rooms) - 1))
player.known_cards[CardType.ROOM].append(card)
self.hidden_players = hidden_players
for player in hidden_players:
PlayerDisplayer().display_player(player)
self.suggesting_player_index = 0
def __init__(self, configuration):
self.board = Board()
player1 = Player(self, configuration["name_player1"],
configuration["intelligence_player1"])
player2 = Player(self, configuration["name_player2"],
configuration["intelligence_player2"])
self.players = (player1, player2)
self.active_player = player1
self.state = self.STATES["WAIT_SELECTION"]
def viewPlayers():
player = Player()
selectedItems = ['', '', '', '', '', '']
playerTeams = []
playerEvents = []
kills = 0
deaths = 0
kd = 0
mapRecord = [0, 0]
results = stats.players.head(0)
results = results.set_index(['Match ID', 'Map ID'])
length = results.shape[0]
if request.method == "POST":
player = Player(request.form.get("player"))
team = request.form.get("team")
opponent = request.form.get("opponent")
event = request.form.get("event")
mode = request.form.get("mode")
map = request.form.get("map")
selectedItems[0] = player.name
selectedItems[1] = team
selectedItems[2] = opponent
selectedItems[3] = event
selectedItems[4] = mode
selectedItems[5] = map
playerTeams = player.getPlayerTeams()
playerEvents = player.getPlayerEvents()
results = stats.getPlayers(player.name, team, opponent, event, mode,
map)
# don't show Match ID and Map ID columns
results = results.set_index(['Match ID', 'Map ID'])
results.dropna(how='all', axis=1, inplace=True)
kills, deaths, kd = player.getPlayerKD(results)
mapRecord[0], mapRecord[1] = player.getPlayerMapRecord(data=results)
length = results.shape[0]
return render_template(
"viewPlayers.html",
player=player,
stats=stats,
tables=[results.to_html(classes="data", index=False)],
playerTeams=playerTeams,
playerEvents=playerEvents,
selectedItems=selectedItems,
kills=kills,
deaths=deaths,
kd=kd,
length=length,
mapRecord=mapRecord)
