def initialization():
deck = Deck()
deck.shuffle()
player = Player()
dealer = Player()
start_game(deck, player, dealer)
def test_board_place_building():
b = Board(2,2)
players = [
Player(0, PlayerColour.RED),
Player(1, PlayerColour.ORANGE),
Player(2, PlayerColour.YELLOW)
]
b.place_building(BuildingType.SETTLEMENT, players[0], 0, 0)
b.place_building(BuildingType.SETTLEMENT, players[1], 0, 2)
b.place_building(BuildingType.SETTLEMENT, players[2], 0, 4)
b.place_building(BuildingType.SETTLEMENT, players[0], 1, 1)
b.place_building(BuildingType.SETTLEMENT, players[1], 1, 3)
b.place_building(BuildingType.SETTLEMENT, players[2], 2, 2)
assert b.corners[0][0].owner.id == 0
assert b.corners[0][1].owner is None
assert b.corners[0][2].owner.id == 1
assert b.corners[0][3].owner is None
assert b.corners[0][4].owner.id == 2
assert b.corners[1][0].owner is None
assert b.corners[1][1].owner.id == 0
assert b.corners[1][2].owner is None
assert b.corners[1][3].owner.id == 1
assert b.corners[1][4].owner is None
assert b.corners[2][0].owner is None
assert b.corners[2][1].owner is None
assert b.corners[2][2].owner.id is 2
assert b.corners[2][3].owner is None
assert b.corners[2][4].owner is None
def load_tournament(self, tournament_json):
tournament = Tournament(
tournament_json['name'], tournament_json['description'],
tournament_json['place'], tournament_json['start_date'],
tournament_json['end_date'], tournament_json['number_of_rounds'],
tournament_json['time_control'])
for player_data in tournament_json['players']:
tournament.players.append(Player(**player_data))
for round_ in tournament_json['rounds']:
new_round = Round(tournament)
new_round.start_time = datetime(
round_['start']['y'],
round_['start']['mo'],
round_['start']['d'],
round_['start']['h'],
round_['start']['mi'],
)
new_round.end_time = datetime(
round_['end']['y'],
round_['end']['mo'],
round_['end']['d'],
round_['end']['h'],
round_['end']['mi'],
)
new_round.end_confirmation = round_['end_confirmation']
for game_data in round_['games']:
new_game = Game(Player(**game_data['player1']),
Player(**game_data['player2']))
new_game.update_result(game_data['result'])
new_round.games.append(new_game)
tournament.rounds.append(new_round)
return tournament
def setUp(self):
team_1 = Team("Barcelona", 27)
team_2 = Team("Real Madrid", 24)
self.teams = [team_1, team_2]
self.player_1 = Player("Hazard", "Real Madrid", "Forward", 12, 8, 0, 0)
self.player_2 = Player("Rodrygo", "Real Madrid", "Forward", 4, 9, 0, 0)
def show_latest_pairs(self) -> list:
pairs = []
latest_round = list(self.rounds.keys())[-1]
for item in self.rounds[latest_round]['matches']:
pairs.append({
'player_1': Player({'id': item[0][0]}).get_player_name(),
'player_2': Player({'id': item[1][0]}).get_player_name()
})
return pairs
def setUp(self) -> None:
self.playground_a = Playground(name='Ramot Sapir', address='Gotel Levin 1, Haifa, Israel',
location=(32.783800, 35.004821),
opening_hours=[('0800', '1400'), ('1600', '2200')])
self.playground_b = Playground(name='Gan Daniel', address='HaShikma 3, Haifa, Israel',
location=(32.786935, 34.994653),
opening_hours=[('0800', '2359')])
self.players = [Player('botzer', 'Amit Botzer', datetime.datetime(1992, 12, 13), 'Haifa'),
Player('botzer92', 'Michael Botzer', datetime.datetime(1992, 12, 13), 'Haifa')]
def main():
arena = Arena(surf=DISPLAY_SURF)
player_1 = Player(name=settings.PLAYER_ONE,
surf=DISPLAY_SURF,
pos=get_player_default_pos(num=settings.PLAYER_ONE))
player_2 = Player(name=settings.PLAYER_TWO,
surf=DISPLAY_SURF,
pos=get_player_default_pos(num=settings.PLAYER_TWO))
ball = Ball(surf=DISPLAY_SURF,
pos=get_ball_default_pos(),
speed=settings.EASY)
clock = Clock(surf=DISPLAY_SURF)
clock.start()
# Stack used to maintain render order
game_objects = [
arena,
player_1,
player_2,
ball,
clock,
]
# Main loop
while True:
# Events
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit_game()
elif event.type == pygame.MOUSEMOTION:
player_1.move((0, event.pos[1] - player_1.y))
# Logic
game_over = check_point_scored(ball)
if game_over:
SoundController.play_game_over()
clock.stop()
elapsed = clock.get_elapsed_seconds()
show_game_over_screen(DISPLAY_SURF, FPS_CLOCK, elapsed)
clock.reset()
clock.start()
ball.reset_velocity()
ball.reposition(get_ball_default_pos())
handle_ball_movement(ball, player_1, player_2)
handle_player_movement(player_2, ball)
# Rendering
render_game_objects(game_objects)
pygame.display.update()
FPS_CLOCK.tick(settings.FPS)
def init_game(self, seed):
"""Inicializa um novo jogo e retorna seu estado."""
player_1 = Player(player_id=1,
player_type=PlayerType.IMPULSIVE,
balance=300)
player_2 = Player(player_id=2,
player_type=PlayerType.RIGOROUS,
balance=300)
player_3 = Player(player_id=3,
player_type=PlayerType.CAUTIOUS,
balance=300)
player_4 = Player(player_id=4,
player_type=PlayerType.RANDOM,
balance=300)
# retira random seed por hora
# random.seed(seed)
# atribui a ordem dos jogadores aleatoriamente
players_list = [player_1, player_2, player_3, player_4]
players_order = players_list.copy()
random.shuffle(players_order)
players_list.insert(0, None)
# Posição -1 é o ponto de partida
# após o começo do jogo essa posição deixa de existir
# ao passar novamente na posição 0, o jogador ganha 100
board = []
board.append(Estate(price=50, rent=10, estate_id=0))
board.append(Estate(price=100, rent=20, estate_id=1))
board.append(Estate(price=150, rent=30, estate_id=2))
board.append(Estate(price=200, rent=40, estate_id=3))
board.append(Estate(price=250, rent=55, estate_id=4))
board.append(Estate(price=300, rent=60, estate_id=5))
board.append(Estate(price=50, rent=10, estate_id=6))
board.append(Estate(price=100, rent=20, estate_id=7))
board.append(Estate(price=150, rent=30, estate_id=8))
board.append(Estate(price=200, rent=40, estate_id=9))
board.append(Estate(price=250, rent=55, estate_id=10))
board.append(Estate(price=300, rent=60, estate_id=11))
board.append(Estate(price=50, rent=10, estate_id=12))
board.append(Estate(price=100, rent=20, estate_id=13))
board.append(Estate(price=150, rent=30, estate_id=14))
board.append(Estate(price=200, rent=40, estate_id=15))
board.append(Estate(price=250, rent=55, estate_id=16))
board.append(Estate(price=300, rent=60, estate_id=17))
board.append(Estate(price=50, rent=10, estate_id=18))
board.append(Estate(price=100, rent=20, estate_id=19))
self.players_list = players_list
self.players_order = players_order
self.board = board
self.round_ = 0
return players_list, players_order, board
def test_GameStateMarshallingWithEnoughPlayers_GameStartAction_StateIsNight():
state = Game()
state.state = GameStates.MARSHALLING
state.players = [Player(), Player(), Player(), Player()]
systemUnderTest = getInstance(state)
success = systemUnderTest.transition(Actions.START_GAME)
assert state.state == GameStates.NIGHT
assert success
def __init__(self, app_ref):
super().__init__(app_ref)
self.current_player_label = Label(self, '', 20)
self.current_player_checker_label = Button(self, '')
self.current_player_checker_label.config(state=tk.DISABLED, width=5)
self.max_depth_label = Label(self, '', 12)
self.board = Board(self)
self.players: {PlayerType: Player} = {
PlayerType.COMPUTER: Player(self, PlayerType.COMPUTER, self.board.blue_checkers),
PlayerType.USER: Player(self, PlayerType.USER, self.board.orange_checkers)
}
def game():
player1_name = request.form['player1_name']
player1_choice = request.form['player1_choice']
player2_name = request.form['player2_name']
player2_choice = request.form['player2_choice']
player1 = Player(player1_name, player1_choice)
player2 = Player(player2_name, player2_choice)
result = two_player_game(player1, player2)
return render_template('index.html', result=result, game=game)
def play_game():
winner = None
player1 = Player(request.form["name-1"], request.form["weapon-1"])
# check both player details have been completed
if request.form.get('name-2'):
player2 = Player(request.form["name-2"], request.form["weapon-2"])
winner = rps.play_game(player1, player2)
else:
winner = rps.play_game(player1)
return render_template('result.html',
title='Result',
winner=winner,
weapon=winner.weapon if winner else player1.weapon)
def __init__(self):
self.screen_width = self.DEFAULT_SCREEN_WIDTH
self.screen_height = self.DEFAULT_SCREEN_HEIGHT
# Needs to happen before objects are initted
pygame.init()
windowSize = (self.screen_width, self.screen_height)
self.screen = pygame.display.set_mode(windowSize,
pygame.DOUBLEBUF | pygame.OPENGL)
# void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);
gluPerspective(60, (windowSize[0] / windowSize[1]), 0.1, 100.0)
# gluOrtho2D(60, (windowSize[0]/windowSize[1]), 0.1, 100.0)
glTranslatef(0.0, 0.0, -5)
self.cubeEdges = ((0, 1), (0, 3), (0, 4), (1, 2), (1, 7), (2, 5),
(2, 3), (3, 6), (4, 6), (4, 7), (5, 6), (5, 7))
self.cubeVertices = ((1, 1, 1), (1, 1, -1), (1, -1, -1), (1, -1, 1),
(-1, 1, 1), (-1, -1, -1), (-1, -1, 1), (-1, 1,
-1))
# self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
self.player = Player(self.screen_width / 2, self.screen_height / 2)
self.cursor = Cursor()
self.running = True
pygame.mouse.set_visible(False)
self.event_listeners = {
'in_game_state': [self.player, self.cursor],
'menu': [self.cursor]
}
self.game_states = ['in_game_state', 'menu', 'options']
self.current_state = self.game_states[0]
def _handle_register(self, text):
import hashlib
self.logger.debug("Recieved register request.")
# register|username|password|password_confirm
usr = text.split("|")[1]
pwd1 = text.split("|")[2]
pwd2 = text.split("|")[3]
if Player.where("name", usr).count() > 0:
self.request.sendall("username_taken".encode("utf8"))
self.request.close()
return
if pwd1 != pwd2:
self.request.sendall("invalid_password".encode("utf8"))
self.request.close()
return
player = Player()
player.name = usr
player.hashed_password = hashlib.sha224(
pwd1.encode("utf8")).hexdigest()
player.save() # Needed to get an ID in the DB
player.guid = hashlib.sha224(
(str(player.id) + player.name +
player.hashed_password).encode("utf8")).hexdigest()
if player.save():
self.request.sendall(
f"register_success|{player.guid}".encode("utf8"))
self.request.close()
else:
self.request.sendall("register_failed!".encode("utf8"))
self.request.close()
def get_player_by_gender_html(column, gender: Gender):
players = []
if not column.table:
return players
for link in column.table.tbody.find_all('tr', recursive=False):
elements = link.find_all("td", recursive=False)
name = elements[1].text
# flags = elements[2].text
number = elements[3].text
# played = elements[4].text
single = elements[5].text
double = elements[6].text
mix = elements[7].text
player = Player(name, gender, number,
PlayerRanking(single, double, mix))
comp_id = re.search(r'aspx\?id=(.+?)((?=\&)|$)',
elements[1].a.get('href')).group(1)
player_comp_id = re.search(r'player=(\d+)',
elements[1].a.get('href')).group(1)
player.add_competition(comp_id, player_comp_id)
players.append(player)
return players
async def show_ranking(self, filter_lobby: bool):
scores = await get_scores(self.channel)
scores = scores.items()
scores = sorted(scores, key=lambda item: item[1], reverse=True)
embed = Embed(colour=Colour.blurple())
embed.title = "Lobby Rankings"
rank = 1
for user_id, score in scores:
user = self.bot.get_user(user_id)
if user is None:
continue
if filter_lobby and Player(user) not in self.players:
continue
embed.add_field(name=f"{rank}. {user}", value=score, inline=False)
rank += 1
if len(embed.fields) == 0:
embed.add_field(
name="No players",
value="No players in the lobby (or channel) have a ranking.",
)
await self.channel.send(embed=embed)
def main():
cprint(
' ███▄ ▄███▓ ▒█████ ███▄ █ ██████ ▄▄▄█████▓▓█████ ██▀███ ██▓███ ██▓ ▄▄▄ ███▄ █ ▓█████▄▄▄█████▓ ',
'green')
cprint(
' ▓██▒▀█▀ ██▒▒██▒ ██▒ ██ ▀█ █ ▒██ ▒ ▓ ██▒ ▓▒▓█ ▀ ▓██ ▒ ██▒ ▓██░ ██▒▓██▒ ▒████▄ ██ ▀█ █ ▓█ ▀▓ ██▒ ▓▒',
'green')
cprint(
' ▓██ ▓██░▒██░ ██▒▓██ ▀█ ██▒░ ▓██▄ ▒ ▓██░ ▒░▒███ ▓██ ░▄█ ▒ ▓██░ ██▓▒▒██░ ▒██ ▀█▄ ▓██ ▀█ ██▒▒███ ▒ ▓██░ ▒░',
'green')
cprint(
' ▒██ ▒██ ▒██ ██░▓██▒ ▐▌██▒ ▒ ██▒░ ▓██▓ ░ ▒▓█ ▄ ▒██▀▀█▄ ▒██▄█▓▒ ▒▒██░ ░██▄▄▄▄██ ▓██▒ ▐▌██▒▒▓█ ▄░ ▓██▓ ░ ',
'green')
cprint(
' ▒██▒ ░██▒░ ████▓▒░▒██░ ▓██░▒██████▒▒ ▒██▒ ░ ░▒████▒░██▓ ▒██▒ ▒██▒ ░ ░░██████▒▓█ ▓██▒▒██░ ▓██░░▒████▒ ▒██▒ ░ ',
'green')
cprint(
' ░ ▒░ ░ ░░ ▒░▒░▒░ ░ ▒░ ▒ ▒ ▒ ▒▓▒ ▒ ░ ▒ ░░ ░░ ▒░ ░░ ▒▓ ░▒▓░ ▒▓▒░ ░ ░░ ▒░▓ ░▒▒ ▓▒█░░ ▒░ ▒ ▒ ░░ ▒░ ░ ▒ ░░ ',
'green')
cprint(
' ░ ░ ░ ░ ▒ ▒░ ░ ░░ ░ ▒░░ ░▒ ░ ░ ░ ░ ░ ░ ░▒ ░ ▒░ ░▒ ░ ░ ░ ▒ ░ ▒ ▒▒ ░░ ░░ ░ ▒░ ░ ░ ░ ░ ',
'green')
cprint(
' ░ ░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ░ ░ ░░ ░ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ',
'green')
cprint(
' ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ',
'green')
print()
player = Player(hp=30)
map = Map()
player.set_location(map.get_starting_location())
game = CommandInterpreter(player, map)
game.run()
def read_player(self):
"""
Generates a table of players and allows to choose a day thanks to its TinyDB ID
:return: ID choice
"""
cls()
icon()
self.list_all_players = list()
for self.player_id in search_all_player():
self.player = Player()
self.player.load_player(self.player_id)
self.list_all_players.append(self.player)
print('Rechercher un Joueur pour ce Tournoi\n')
print(("=" * 177).center(width_calculated()))
print(f'| {"ID du Joueur".center(25)} |'
f'{"Nom du Joueur".center(35)} |'
f'{"Prénom du Joueur".center(35)} |'
f'{"Date de naissance du joueur".center(35)} |'
f'{"Rang".center(35)} |'.center(width_calculated())
)
self.list_all_players = sorted(self.list_all_players, key=lambda player: player.name)
for self.player in self.list_all_players:
print(("-" * 177).center(width_calculated()))
print(f'| {str(self.player.id).center(25)} |'
f'{self.player.name.center(35)} |'
f'{self.player.first_name.center(35)} |'
f'{self.player.date_born.center(35)} |'
f'{str(self.player.rank).center(35)} |'.center(width_calculated())
)
print(("-" * 177).center(width_calculated()))
self.ID = str()
while not re.match(r"^[0-9]+$", self.ID):
self.ID = input('Taper l ID du Joueur : ')
return self.ID
def newGameOrLoad() -> Optional[Player]:
"""Asks the user to load or start new game."""
start_option:str = askWithOptions(["Start New Game", "Load Saved Game"])
if start_option == "start new game":
# Create a new player.
print("Choose a name...")
name: str = askInput()
return Player(name)
else:
# Load player.
saves_path: str = getcwd() + "\\saves"
if not exists(saves_path):
mkdir(saves_path)
saves = [f for f in listdir(saves_path) if isfile(join(saves_path, f))]
saves.append("Go Back")
print("Choose a save file:")
save_file: str = askWithOptions(saves)
if save_file == "go back":
return None
try:
return pickle.load(open(saves_path + "/" + save_file, "rb+"))
except TypeError as e:
print(str(e))
print("Couldn't load {0}. Make sure the file hasn't been corrupted!\n".format(save_file))
return None
def select(id):
sql = "SELECT * FROM players WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
team = team_repo.select(result["team_id"])
player = Player(result["name"], result["position"], result["rating"], team, result["id"])
return player
def update_player(id):
name = request.form["name"]
player_info = request.form["player_info"]
goals_scored = request.form["goals_scored"]
player = Player(name, player_info, goals_scored, id)
player_repository.update(player)
return redirect("/clubs/players")
def setUp(self):
"""
Initialize test http client and set up the requestContext
:return:
"""
# These are needed to avoid a credential error when testing
os.environ["AWS_ACCESS_KEY_ID"] = "test"
os.environ["AWS_SECRET_ACCESS_KEY"] = "test"
from utils import utils
from micro_airlines_api import app
self.utils = utils
self.assertEqual(app.debug, False)
self.http_client = app.test_client()
self.test_player_1 = Player(player_id='test_player_1', balance=100000)
self.request = {
'requestContext': {
'authorizer': {
'claims': {
'cognito:username': self.test_player_1.player_id
}
}
}
}
self.http_client.environ_base['awsgi.event'] = self.request
def load_stats_file(name: str):
"""Return player object given a name"""
if not hash_stats(name):
return None
try:
with open(stats_path(name), "r", encoding='UTF-8') as stats_file:
player = Player(name)
player.kills = int(stats_file.readline())
player.deaths = int(stats_file.readline())
player.flag_grabs = int(stats_file.readline())
player.flag_caps_red = int(stats_file.readline())
player.flag_caps_blue = int(stats_file.readline())
player.flag_time = float(stats_file.readline())
player.flagger_kills = int(stats_file.readline())
player.best_spree = int(stats_file.readline())
player.wins = int(stats_file.readline())
player.looses = int(stats_file.readline())
player.a_haxx0r = str(stats_file.readline())
player.a_blazeit = str(stats_file.readline())
player.a_satan = str(stats_file.readline())
player.a_virgin = str(stats_file.readline())
stats_file.close()
return player
except OSError:
say("[ERROR] (load) failed to loaded stats for name='" + name +
"' filename='" + stats_path(name) + "'")
sys.exit(1)
return None
def start_multiplayer():
'''
Makes two *Player* objects and starts the multiplayer mode.
Returns
-------
None
'''
players = Ui.get_inputs(["First player's name", "Second player's name"],
"Please provide your names")
player1 = Player(players[0])
player2 = Player(players[1])
gameplay = Game(player1, player2)
gameplay.start_game()
async def queue(self, ctx: commands.Context, time_to_queue: int = None):
if ctx.channel.name != os.environ.get("6_MAN_CHANNEL"):
return
if self.users_in_queue.get(ctx.author.id, False):
await ctx.channel.send(
f"You are already in the queue, {ctx.author.mention}.")
return
prefix = await self.bot.get_prefix(ctx.message)
res = record("SELECT * FROM player WHERE discord_id = ?",
ctx.author.id)
if res is None:
await ctx.channel.send(
f"You have not set your mmr, please use: `{prefix}setpeak <amount>`!\n\nIf you need to find what your mmr is, go here: https://rocketleague.tracker.network/"
)
return
# add user to queue
self.users_in_queue[ctx.author.id] = Player(ctx.author, res[1])
# if user is only in queue for certain amount of time, create task to check in said time
if time_to_queue is not False and time_to_queue > 0:
asyncio.gather(self._remove_user(ctx, time_to_queue))
embed = embed_template.copy()
if len(self.users_in_queue) == 1:
embed.add_field(
name="Queue Started!",
value=
f"{ctx.author.mention} has started a queue, type `{prefix}q` or `{prefix}queue` to join!",
inline=False,
)
else:
embed.add_field(
name="User Joined the Queue!",
value=
f"{ctx.author.mention} joined the queue, type `{prefix}q` or `{prefix}queue` to join!",
inline=False,
)
embed.add_field(
name=f"Users in Queue: {str(len(self.users_in_queue))}",
value=", ".join(player.get_discord_user().mention
for player in self.users_in_queue.values()),
inline=False,
)
await ctx.channel.send(embed=embed)
if len(self.users_in_queue) == 6:
game_players = []
for i in range(6):
game_players.append(self.users_in_queue.popitem(last=False)[1])
game_handler = GameHandler(6, game_players)
await self.create_game(ctx, game_handler)
def add_player():
new_player = request.form['new_player']
# name = player_repository.select(new_player)
player = Player(new_player)
player_repository.save(player)
return redirect('/players')
def __init__(self):
"""
Create the main player menu stats
"""
cls()
icon()
self.list_all_player_id = search_all_player()
self.list_players = []
for self.player_id in self.list_all_player_id:
self.player = Player()
self.player.load_player(int(self.player_id))
self.list_players.append(self.player)
print("Menu des stats Joueur \n\n"
"1. Voir la liste des Joueurs par ordre Alphabétique\n"
"2. Voir la liste des Joueurs par ordre de Rang\n"
"3. Retour\n")
self.choice_menu = 0
while not 3 >= int(self.choice_menu) >= 1:
self.choice_menu = input(
"Faites votre choix un tapant le numéro de menu (ex. 1, 2, ne taper qu'un seul choix) : "
)
if not self.choice_menu.isdigit():
self.choice_menu = 0
if int(self.choice_menu) == 1:
self.show_players_sort(False)
input()
elif int(self.choice_menu) == 2:
self.show_players_sort(True)
input()
elif int(self.choice_menu) == 3:
pass
def add_player(self):
c = main.MainController()
last_name = c.input_with_options('Last name : ')
first_name = c.input_with_options('First name : ')
date_regex = re.compile(r'^(0[1-9]|[1-2][0-9]|3[0-1])'
r'/(0[1-9]|1[0-2])/[0-9]{4}$')
birthday = c.input_with_options(
'Birthday (dd/mm/yyyy) : ',
date_regex,
'Please enter a valid date format (dd/mm/yyyy)',
loop=True)
gender = c.input_with_options('gender (m/w) : ',
re.compile(r'^[m|w]$'),
'Please enter m or w',
loop=True)
rank = c.input_with_options('Current rank : ',
re.compile('^[0-9]+$'),
'Please enter en positive number',
loop=True)
player = Player(last_name, first_name, birthday, gender, rank)
Player.add_player(player)
def select(id):
sql = "SELECT * FROM players WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
player = Player(result["name"], result["player_info"],
result["goals_scored"], result["id"])
return player
def get_player_list(url):
try:
page = requests.get(url)
except:
print('Error! Could not get file at url:', url)
return PlayerList([])
soup = BeautifulSoup(page.content, "html.parser")
table = soup.find(id="salaries-table")
rows = table.find_all("tr")
player_list = []
for row in rows:
cells = row.find_all("td")
player_info = {}
for cell in cells:
player_info[cell.attrs["class"][0]] = cell.text
player_list.append(
Player(
name=player_info["player-name"],
salary=player_info["player-salary"],
year=player_info["player-year"],
level=player_info["player-level"],
))
return PlayerList(player_list)
