def player_team(self, player):
home = [
self.home_boxscore['teamId']
for stat in self.home_boxscore['playerstats']
if stat['player']['playerId'] == player.id
]
away = [
self.away_boxscore['teamId']
for stat in self.away_boxscore['playerstats']
if stat['player']['playerId'] == 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))
class GameEngine:
"""GameEngine class for demonstration"""
"""Let us create a team and set its strategy,
and make the teams play the game"""
"""Create few strategies"""
attack = AttackStrategy()
defend = DefendStrategy()
"""Create our teams"""
france = Team("France")
italy = Team("Italy")
print "Setting the strategies.."
"""Now let us set the strategies"""
france.SetStrategy(attack)
italy.SetStrategy(defend)
"""Make the teams start the play"""
france.PlayGame()
italy.PlayGame()
print "Changing the strategies.."
"""Let us change the strategies"""
france.SetStrategy(defend)
italy.SetStrategy(attack)
"""Make them play again"""
france.PlayGame()
italy.PlayGame()
"""Wait for a key press"""
print "Press any key to continue..."
raw_input()
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((self.screen_w, self.screen_h))
self.fps_clock = pygame.time.Clock()
# 2D array containing arrays, to store object in the secotrs and optimise collisions
self.sectors = [[[]
for j in range(ceil(self.screen_h / self.sector_size))
]
for i in range(ceil(self.screen_w / self.sector_size))]
# create goals
screen_margin = (self.screen_h - self.pitch_h) / 2
self.goal_left = Goal(self, self.pitch_color_1,
(self.screen_w - self.pitch_w) / 2,
screen_margin + self.pitch_h * 6 / 16,
screen_margin + self.pitch_h * 10 / 16, 50, -1)
self.goal_right = Goal(
self, self.pitch_color_2,
self.pitch_w + (self.screen_w - self.pitch_w) / 2,
screen_margin + self.pitch_h * 6 / 16,
screen_margin + self.pitch_h * 10 / 16, 50, 0)
self.team_right = Team(self, self.team1_color, self.goal_right, 1)
self.team_left = Team(self, self.team2_color, self.goal_left, -1)
self.start_time = pygame.time.get_ticks()
def __init__(self, date, day, home_team_id, vis_team_id, time, league, db):
self.date = date
self.day = day
self.vis_team_id = vis_team_id
self.home_team_id = home_team_id
self.time = time
self.league = league
self.vis_bat = Bat(vis_team_id, db)
self.vis_pitch = Pitch(vis_team_id, db)
self.vis_team = Team(vis_team_id, db, self.vis_bat, self.vis_pitch,
league)
self.home_bat = Bat(home_team_id, db)
self.home_pitch = Pitch(home_team_id, db)
self.home_team = Team(home_team_id, db, self.home_bat, self.home_pitch,
league)
self.h_pow_v_vs_pow, self.h_cont_v_vs_cont, \
self.h_scor_v_vs_scor, self.h_b_over_b_p_over, \
self.h_vs_pow_v_pow, self.h_vs_cont_v_cont, \
self.h_vs_scor_v_scor, self.h_p_over_v_b_over = Utils.compare_teams(self.home_team, self.vis_team)
self.total = Utils.compare_teams(self.home_team, self.vis_team)
self.favorite, self.moneyline = Utils.get_moneyline(
self.home_team, self.vis_team)
def __init__(self, filename):
team1, team2, ball = [], [], []
checkIndex = -1
with open(filename, 'r') as file: # Copy the data from the file to temporary list
for line in file:
if checkIndex >= 0:
if checkIndex % self._numOfPlayers < teamSize:
team1.append(line[:-1])
elif (self._numOfPlayers - 1) > (checkIndex % self._numOfPlayers) >= teamSize:
team2.append(line[:-1])
else:
ball.append(line[:-1])
else:
self._numOfPlayers = int(line[:-1])
teamSize = (self._numOfPlayers - 1) / 2
teamSize = int(teamSize)
checkIndex += 1
if team1.__len__() == 0 or team2.__len__() == 0 or ball.__len__() == 0:
print("failed open file")
return None
self._objects = []
self._objects.append(Team(Color.FIRST_TEAM, teamSize, team1))
self._objects.append(Team(Color.SEC_TEAM, teamSize, team2))
self._objects.append(Ball(Color.BALL, ball))
def GetAllGames(all_game_lists, all_games_finished):
index = 'A'
games_list = []
for item in all_game_lists:
team_vs = GetOneElementByClass(item, 'div', 'team_vs')
team_details_div = GetElementsByClass(team_vs, 'div', 'txt')
team_score_a = GetOneElementByClass(team_details_div[0], 'span', 'num')
team_score_b = GetOneElementByClass(team_details_div[1], 'span', 'num')
team_score_a = GetTextOfItem(team_score_a, '0')
team_score_b = GetTextOfItem(team_score_b, '0')
team_name_a = GetTextOfItem(team_details_div[0].find('a'))
team_name_b = GetTextOfItem(team_details_div[1].find('a'))
team_a = Team(name=team_name_a, score=team_score_a)
team_b = Team(name=team_name_b, score=team_score_b)
team_vs_time = GetOneElementByClass(team_vs, 'span', 'b')
team_vs_time = GetTextOfItem(team_vs_time, ' 未开始')
games_list.append(Game(index, team_a, team_b, team_vs_time))
index = chr(ord(index) + 1)
return games_list
def read_json(self):
game_df = pd.read_json(self.path_to_json)
event = Game.load_event_by_num(game_df, self.event_num)
self.event = Event(event)
self.home_team = Team(event['home']['teamid'])
self.guest_team = Team(event['visitor']['teamid'])
def scrapeMatchFromRow(self, row):
data = row.findAll('td')
homeClub, homeLevel = getClubAndLevelFromTeamName(data[1].text)
awayClub, awayLevel = getClubAndLevelFromTeamName(data[2].text)
homeTeam = Team(homeClub, homeLevel)
awayTeam = Team(awayClub, awayLevel)
startDate = data[0].text
startDate = datetime.strptime(startDate, '%d-%m-%Y').date()
startTime = data[4].text
startTime = datetime.strptime(startTime, '%H:%M').time()
try:
meetingTime = data[3].text
meetingTime = datetime.strptime(meetingTime, '%H:%M').time()
except:
meetingTime = startTime
meetingDateTime = datetime.combine(startDate, meetingTime)
startDateTime = datetime.combine(startDate, startTime)
endDateTime = startDateTime + MATCH_DURATION
# Assume that returning takes the same amount of time as the time between meeting and start of the match.
returnedDateTime = endDateTime + (startDateTime - meetingDateTime)
referee = Referee("Not Scheduled", "", "", "", "", "", [])
match = Match(homeTeam, awayTeam, meetingDateTime, startDateTime,
endDateTime, returnedDateTime, referee)
return match
def query_game_details(game_id):
ou_site = "http://site.api.espn.com/apis/site/v2/sports/football/college-football/summary?event=" + game_id
response = requests.get(ou_site, timeout=5)
game_data = response.json()
teams = game_data['header']['competitions'][0]['competitors']
team1 = Team(teams[0])
team2 = Team(teams[1])
return team1, team2
def __init__(self):
self.pitch = Pitch()
self.home_team = Team(True, pitch=self.pitch)
self.away_team = Team(False, pitch=self.pitch)
self.current_frame_number = 0
self.flip5050()
self.store_frame()
self.current_frame.print_frame()
def setup(self):
#setup directory to save the images
try:
os.mkdir(self.imageDirName)
except:
print self.imageDirName + " subdirectory already exists. OK."
#define teams which the agents can be a part of
predator = Team("Predator", '#ff99ff')
prey = Team("Prey", '#ffcc99')
#Defining a couple of agents
#predator and prey counts
predatorCount = 5
preyCount = 10
displacement = array([0, 20, 0])
#initial seed positions
predatorPos = array([20, 0, 0])
preyPos = array([0, 0, 0])
#set seed for randomly placing predators
random.seed(20)
#initialize predators
for i in range(0, predatorCount):
brain = PredatorBrain()
x = random.random() * 30
y = random.random() * 30
z = random.random() * 30
newDisplacement = array([x, y, z])
agent = Agent(predator, predatorPos, array([0, 0, 0]), brain, 5, 5,
5)
self.world.addAgent(agent)
predatorPos += newDisplacement
#initialize prey
for i in range(0, preyCount):
brain = PreyBrain()
agent = RestrictedAgent(prey, preyPos, array([0, 0, 0]), brain, 2,
200, 2, 2)
self.world.addAgent(agent)
preyPos += displacement
#
#define a bunch of obstacles
ob1Pos = array([-50, -50, -50])
ob1 = Obstacle(ob1Pos, 30)
ob2Pos = array([80, -50, -50])
ob2 = Obstacle(ob2Pos, 20)
originRef = Obstacle(array([0.1, 0.1, 0.1]), 10)
#add obstacles to the world
self.world.addObstacle(ob1)
self.world.addObstacle(originRef)
def stats_mod(home_players, away_players):
game_data_array = []
calc_stats(home_players, 240)
calc_stats(away_players, 240)
game_data_array.extend(Team(home_players).export())
game_data_array.extend(Team(away_players).export())
return game_data_array
def __init__(self, team1_name, team2_name):
self.team1_name = team1_name
self.team2_name = team2_name
self.team1 = Team(self.team1_name, random.choice(self.location))
self.team2 = Team(self.team2_name, random.choice(self.location))
self.team1_pass = Pass(self.team1_name, self.team2_name)
self.team2_pass = Pass(self.team2_name, self.team1_name)
self.team1_shot = Shoot(self.team1_name, self.team2_name)
self.team2_shot = Shoot(self.team2_name, self.team1_name)
def __init__(self, boardState, oldCell, newCell, teamR, teamL):
self.children = []
self.boardState = boardState
# Instead of tracking the piece that's moving, just track the cells and handle it appropriately further up
self.oldCell = oldCell
self.newCell = newCell
#white is right
self.teamR = Team(teamR.r, teamR.g, teamR.b)
self.teamL = Team(teamL.r, teamL.g, teamL.b)
def read_json(self):
data_frame = pd.read_json(self.path_to_json)
last_default_index = len(data_frame) - 1
self.event_index = min(self.event_index, last_default_index)
index = self.event_index
print(Constant.MESSAGE + str(last_default_index))
event = data_frame['events'][index]
self.event = Event(event, self.path_to_json, self.event_index)
self.home_team = Team(event['home']['teamid'])
self.guest_team = Team(event['visitor']['teamid'])
def FormTeam(available_robots, part, pose):
# FIXME For now return a fixed team for each part
if part.GetName() == 'WingSkin':
# Choose the first robot
team = Team([available_robots[0]])
elif part.GetName() == 'Fastener':
# Choose the third robot
team = Team([available_robots[2]])
else:
raise Exception('Unknown part name: %s' % (part.GetName()))
return team
def setUp(self):
self.public = True
self.private = False
self.Stud1 = Student(1, "Stud1", self.private)
self.Stud2 = Student(2, "S2", self.private)
self.T1 = Team("Team1", 1, self.public, self.L1)
self.T2 = Team("Team2", 2, self.public, self.L2)
self.C1 = Course(10000, "CSCI-4440", 1, 75)
self.C2 = Course(10001, "CSCI-4460", 1, 75)
def compile_data(self):
game_data_array = [
int(self.game_id), int(self.home_win)
] # array that stores the stats --> corresponds to a single row in the CSV file
calc_stats(self.home_players, 240)
calc_stats(self.away_players, 240)
game_data_array.extend(Team(self.home_players).export())
game_data_array.extend(Team(self.away_players).export())
return game_data_array
def __init__(self, event_moments, player_info, event_description,
probability_to_make, shot_time, feat_info):
home_team_player_id = player_info[0][0]
away_team_player_id = player_info[0][5]
home_team_id = Constant.PLAYER_LIST[Constant.PLAYER_LIST['player_id']
== home_team_player_id].iloc[0, 0]
away_team_id = Constant.PLAYER_LIST[Constant.PLAYER_LIST['player_id']
== away_team_player_id].iloc[0, 0]
self.home_team = Team(home_team_id)
self.guest_team = Team(away_team_id)
self.event = Event(event_moments, player_info, event_description,
probability_to_make, shot_time, feat_info)
def __init__(self):
self.window = Window()
self.window.takeTurnButton.clicked.connect(self.takeTurn)
self.window.moveButton.clicked.connect(self.moveCharacter)
self.window.dealDamagebutton.clicked.connect(self.dealDamage)
self.window.undoButton.clicked.connect(self.undo)
self.teams = [Team([]), Team([])]
self.window.loadMap(the_map.map)
for button in self.window.playerButtons:
button.clicked.connect(self.playerButtonListener)
self.currentPath = []
self.window.printStatsButton.clicked.connect(self.printStats)
self.window.resetCharacterButton.clicked.connect(self.resetCharacter)
def __init__(self, region, playerPool):
assert len(playerPool) == Game.N_PLAYERS
self.id = IdGen()
self.region = region
self.state = State.TERRAN_PICK
self.playerPool = {player.id:player for player in playerPool}
self.zergCapt = self.ChooseCaptain(Race.ZERG)
self.terranCapt = self.ChooseCaptain(Race.TERRAN)
self.zerg = Team(self.zergCapt)
self.terran = Team(self.terranCapt)
self.playerTurn = self.terranCapt
self.pickedCnt = 0
self.timeStarted = None
def read_json(self):
data_frame = pd.read_json(self.path_to_json)
# Setup game parameters and players
event = data_frame['events'][0]
self.home_team = Team(event['home']['teamid'])
self.guest_team = Team(event['visitor']['teamid'])
self.player_ids_dict = self.get_player_dict(event)
print('Setting up player dictionaries...')
temp_player_ids_dicts_all = []
for event in data_frame['events']:
player_dict = self.get_player_dict(event)
temp_player_ids_dicts_all.extend(
[player_dict for _ in range(len(event['moments']))])
print('Setting up moment dictionary...')
moments_list = [m for e in data_frame['events'] for m in e['moments']]
# divide moments based on each quater
quater_list = [[] for _ in range(4)]
quarter_player_dict_list = [[] for _ in range(4)]
for moment, player_dict in zip(moments_list,
temp_player_ids_dicts_all):
quater_list[int(moment[0]) - 1].append(moment)
quarter_player_dict_list[int(moment[0]) - 1].append(player_dict)
# Create quater dict for each quater
print('Creating moments...')
self.moments = []
self.player_ids_dicts_all = []
for i in range(4):
d_list = [(m[2], m, pl_dt) for m, pl_dt in zip(
quater_list[i], quarter_player_dict_list[i])]
moment_dict = {key: value for (key, value, _) in d_list}
player_dict = {key: value for (key, _, value) in d_list}
moment_keys = list(sorted(list(moment_dict.keys()), reverse=True))
cur_moments = [
Moment(moment_dict[mk], player_dict[mk]) for mk in moment_keys
if isinstance(moment_dict[mk][3], float)
]
cur_player_dicts = [
player_dict[mk] for mk in moment_keys
if isinstance(moment_dict[mk][3], float)
]
self.moments.extend(cur_moments)
self.player_ids_dicts_all.extend(cur_player_dicts)
def setUp(self):
self.public = True
self.private = False
self.L1 = Student(1, "L1", self.private)
self.L2 = Student(2, "L2", self.private)
self.M11 = Student(11, "M11", self.private)
self.M12 = Student(12, "M12", self.private)
# initialize Team Objects Team(name, id, publicity, leader)
# v
# Student(id, username, publicity)
self.Team1 = Team("Team1", 1, self.public, self.L1)
self.Team2 = Team("Team2", 2, self.private, self.L2)
def __init__(self, player):
self.team = Team(player[0])
self.id = player[1]
self.x = player[2]
self.y = player[3]
self.z = 0.8
self.color = self.team.color
def rows_to_team(team_rows):
team = Team()
for i in range(1, len(team_rows)):
columns = team_rows[i].findAll("td")
popflash_id = get_popflash_id(columns)
player = Player(popflash_id)
try:
s = str(columns[0].text.strip()[0])
player.set_nick(columns[0].text.strip())
# Captain gets cactus symbol in front of name. Remove this
except UnicodeEncodeError:
player.set_nick(columns[0].text.strip()[1:])
player.set_kills(columns[1].text.strip())
player.set_assists(columns[2].text.strip())
player.set_deaths(columns[3].text.strip())
player.set_flash_assists(columns[4].text.strip())
player.set_adr(columns[5].text.strip())
player.set_hltv_rating(columns[6].text.strip())
player.set_hs_percentage(columns[7].text.strip())
player.set_clutch_kills(columns[8].text.strip())
player.set_bombs_planted(columns[9].text.strip())
player.set_bombs_defused(columns[10].text.strip())
img_url = get_user_image(popflash_id)
player.set_img_url(img_url)
team.add_player(player)
return team
def generate_n_teams(self, n):
oprs = []
for i in range(1, n + 1):
t = Team(i, -1)
self.teams.append(t)
# if more than 32 teams, use worlds-like distribution
if (n > 32):
oprs = np.random.normal(150, 55, n)
# if 32 > n > 24, use state-like distribution
elif (n > 24):
oprs = np.random.normal(125, 55, n)
# else for smaller tournaments, use qual-like distribution
else:
oprs = np.random.normal(100, 55, n)
oprs.sort()
o = 0
for t in reversed(self.teams):
temp = int(oprs[o])
# min opr is 10, max is 450
if temp < 10: temp = 10
if temp > 450: temp = 450
t.opr = temp
o += 1
def simLeague(l, k):
for team in l.teams:
t = Team(team)
l.Teamlist.append(t)
for match in l.matches:
team1id = 0
team2id = 0
for team in l.Teamlist:
if team.teamname == match.home_team:
team1id = l.Teamlist.index(team)
if team.teamname == match.away_team:
team2id = l.Teamlist.index(team)
if (l.matches.index(match) > len(l.matches) / guessafterpercentageofmatches):
match = Predict.predictmatch(match, k, l.Teamlist[team1id], l.Teamlist[team2id], l)
l.updatewresult(team1id, team2id, match.home_score, match.away_score)
# t1=l.Teamlist[team1id]
# t2=l.Teamlist[team2id]
# print(t1.teamname,t1.form,t1.totalGoals,t1.totalConcede)
l.totalmatch += 1
if match.result == "H":
l.homewin += 1
if match.result == "D":
l.draw += 1
if match.result == "A":
l.awaywin += 1
l.homescored += match.home_score
l.awayscored += match.away_score
l.results.append(match)
return l
def load_game(self, file_name):
self.players = []
current_team_name = None
current_team_obj = None
with open(file_name, "r") as f:
first_line = f.readline()
if first_line[0] == "M":
self.map_name = first_line.split(":")[1].rstrip()
self.world = World(self.map_name)
print("creating map from " + self.map_name)
self.set_color_prefs(Game.default_prefs)
for line in f:
# print(line[0])
if line[0] == "t":
current_team_name = line.split("-")[1].split("@")[0]
host, port = line.split("-")[1].split("@")[1].split(":")
port = int(port)
print("creating new team: " + current_team_name)
current_team_obj = Team(self.world, current_team_name)
self.add_player(Server_Facing_Networked_Player(self, current_team_obj, host, port))
elif line[0] == "m":
loc = location(line.split("@")[1][:-1])
current_team_obj.create_mech(line[2:6], loc)
elif line[0] == "s":
loc = location(line.split("@")[1][:-1])
self.world.create_station_at(loc, current_team_obj)
def teamBuilder(existing=None):
for team in team_names:
team_players = []
payroll = 0.0
ratings = []
base_money = 200000000
wins = 0
losses = 0
playoffwins = 0
cap = 99000000
if existing:
wins = teams[team_names.index(team)].getWins()
losses = teams[team_names.index(team)].getLosses()
playoffwins = teams[team_names.index(team)].getPlayoffWins()
cap = teams[team_names.index(team)].getCap()
for player in players:
if (player.getTeam() == team):
team_players.append(player)
ratings.append(player.getRating())
payroll += player.getSalary()
team_rating = sum(ratings) / float(len(ratings))
teamBuilt = Team(team, team_players, payroll, team_rating, wins,
losses, base_money, playoffwins, cap)
if existing:
teams[team_names.index(team)] = teamBuilt
else:
teams.append(teamBuilt)
def pruning_test():
# Setup Team Object
team_edm = Team()
lines = list()
lines.append(Line(0, 1.701))
lines.append(Line(1, 0.658))
lines.append(Line(2, 0.299))
lines.append(Line(3, 0.433))
team_edm.set_team("EDM", lines=lines,
start_line_index=0) # Edmonton Oilers
path = Path()
path.team = team_edm
values_best = []
for i in range(30):
temp_path = path.copy()
optimal_path, num_visited = process(team_edm[team_edm.curr_line_index],
temp_path, 1, i)
values_best.append(num_visited)
path.team[path.team.curr_line_index].toi = 0
values_worst = []
for i in range(30):
temp_path = path.copy()
optimal_path, num_visited = process(team_edm[team_edm.curr_line_index],
temp_path, 1, i)
values_worst.append(num_visited)
theoretical_values = [theoretical_nodes(i) for i in range(30)]
print(theoretical_values)
print(values_best)
print(values_worst)
