def __init__(self, moment, player_jersey):
self.quarter = moment[0]
self.game_clock = moment[2]
self.shot_clock = moment[3]
# Ball info
ball_info = {'x': moment[5][0][2],
'y': moment[5][0][3],
'radius': moment[5][0][4]
}
self.ball = Ball(ball_info)
# Player info
self.players = []
team_id_set = set()
for item in moment[5][1:]:
team_id_set.add(item[0])
color = Team.color_dict[item[0]][0]
player = {'id':item[1],
'x': item[2],
'y':item[3],
'jersey':player_jersey[item[1]],
'color': color
}
self.players.append(Player(player))
# Team info
self.teams = (Team(team_id_set.pop()), Team(team_id_set.pop()))
def __init__(self, map_name, config=None, train=False):
super(Game, self).__init__(map_name, config=config, train=train)
self.default_setup()
# Initialize 2 teams with one player each
self.teams: Dict[int, Team] = {1: Team(), 2: Team()}
self.teams[1].add_player(Player(self.players[0], 1, self))
self.teams[2].add_player(Player(self.players[1], 2, self))
self.euclidean_mat = dict()
self.manhattan_mat = dict()
self.create_distance_matrices(10, 10)
self.prev_stat = None
def player_team(self, player):
home = [self.home_boxscore['team_id']
for stat in self.home_boxscore['playerstats']
if stat['player']['id'] == player.id]
away = [self.away_boxscore['team_id']
for stat in self.away_boxscore['playerstats']
if stat['player']['id'] == player.id]
if home != [] and away == []:
return Team(home[0])
elif home == [] and away != []:
return Team(away[0])
elif home == [] and away == []:
raise GameDataError('No such player in this game: {}'.format(player))
elif home != [] and away != []:
raise GameDataError('Same player {} on two different teams! Something is terribly wrong!'.format(player))
def test_ortg_drtg(self):
team = Team(6)
drtg = self.season.drtg(team)
ortg = self.season.ortg(team)
print ortg, drtg
self.assertAlmostEqual(ortg, 111.8, delta=0.5)
self.assertAlmostEqual(drtg, 109.2, delta=0.5)
def test_get_team_stats_by_time(self):
team = Team(12)
players = [Player(399725), Player(3085)]
timestream = self.game.multiple_player_overlap(players)[0]
stats = self.game.team_stats_by_time(team, timestream)
pprint(stats.__dict__)
self.assertEqual(stats.assists, 13)
self.assertEqual(stats.field_goals_attempted, 40)
self.assertEqual(stats.field_goals_made, 18)
def get_win_probability(left_powers: list, right_powers: list, mode: Mode):
"""
This function gets probability
of win, if both players should
choose first alive gladiators
"""
def get_left_win_prob(cur_state: State):
if not cur_state.team_left.is_alive():
return 0
elif not cur_state.team_right.is_alive():
return 1
else:
state_left_win = cur_state.__copy__()
state_right_win = cur_state.__copy__()
rules_left_win = Rules(state_left_win, mode)
rules_right_win = Rules(state_right_win, mode)
left_glad = cur_state.team_left[0]
right_glad = cur_state.team_right[0]
prob_glad_win = rules_left_win \
.get_probability_glad_win(left_glad, right_glad)
rules_left_win.fight(state_left_win.team_left[0],
state_left_win.team_right[0],
mode='test',
winner=Party.LEFT)
rules_right_win.fight(state_right_win.team_left[0],
state_right_win.team_right[0],
mode='test',
winner=Party.RIGHT)
return prob_glad_win[0] * get_left_win_prob(rules_left_win.state) \
+ prob_glad_win[1] * get_left_win_prob(rules_right_win.state)
left_team = Team(powers=left_powers)
right_team = Team(powers=right_powers)
prob_left_win = get_left_win_prob(State(left_team, right_team))
return prob_left_win, 1 - prob_left_win
def __init__(self, powers: list, party: Party):
self.team = Team(powers=powers)
self.party = party
def away_team(self):
return Team(self._away_team['id'])
def home_team(self):
return Team(self._home_team['id'])