public async Task BindTeams(string season)
{
var teams = (await JsonReader.GetTeamsAsync(season)).ExtractTeamStats(season);
TeamGridWest.ItemsSource = TeamStats.CorrectStanding(teams.Where(t => t.Conference == "West"));
TeamGridEast.ItemsSource = TeamStats.CorrectStanding(teams.Where(t => t.Conference == "East"));
}
private void AddGameToTeamStats(List <Player> players, bool isTerroristTeam, GameOutcome outcome, List <TeamStats> teams)
{
if (players.Count == 0)
{
return;
}
var team = teams.FirstOrDefault(teamStats => IsSameTeam(teamStats.Players, players));
if (team == null)
{
var playerInfos = players.Select(player => GetPlayerInfo(player));
playerInfos = playerInfos.OrderBy(player => player.Name);
team = new TeamStats(playerInfos.ToList());
teams.Add(team);
}
if (outcome == GameOutcome.Draw)
{
team.Draws++;
}
else if (
isTerroristTeam && outcome == GameOutcome.TerroristsWin ||
!isTerroristTeam && outcome == GameOutcome.CounterTerroristsWin
)
{
team.Wins++;
}
else
{
team.Losses++;
}
}
// Start is called before the first frame update
void Start()
{
gameManager = FindObjectOfType <GameManager>();
gameSpeedController = FindObjectOfType <GameSpeedController>();
switch (teamBlack.GetTeam())
{
case TeamName.BlackTeam:
teamAStats = ScoreKeeper.GetBlackTeamStats();
teamBStats = ScoreKeeper.GetRedTeamStats();
break;
case TeamName.RedTeam:
teamAStats = ScoreKeeper.GetRedTeamStats();
teamBStats = ScoreKeeper.GetBlackTeamStats();
break;
}
teamAStats = ScoreKeeper.GetBlackTeamStats();
teamBStats = ScoreKeeper.GetRedTeamStats();
gameSpeedController.speed = testSpeed;
StartNewTest();
}
public void DefualtConstructorSetYearToCurrentYearAndSetDefaultValues()
{
var teamStats = new TeamStats();
Assert.AreEqual(DateTime.Now.Year, teamStats.Year);
Assert.AreEqual(0, teamStats.Wins);
Assert.AreEqual(0, teamStats.Losses);
CollectionAssert.AreEqual(new List <int> {
DateTime.Now.Year
}, teamStats.Seasons);
Assert.IsNotNull(teamStats.PlayerYearStats);
Assert.IsFalse(teamStats.PlayerYearStats.Any());
Assert.AreEqual(0, teamStats.TotalAtBats);
Assert.AreEqual(0, teamStats.TotalRuns);
Assert.AreEqual(0, teamStats.TotalHits);
Assert.AreEqual(0, teamStats.TotalDoubles);
Assert.AreEqual(0, teamStats.TotalTriples);
Assert.AreEqual(0, teamStats.TotalHomeRuns);
Assert.AreEqual(0, teamStats.TotalRunsBattedIn);
Assert.AreEqual(0, teamStats.TotalWalks);
Assert.AreEqual(0, teamStats.TotalStrikeOuts);
Assert.AreEqual(0, teamStats.TotalAverage);
Assert.AreEqual(0, teamStats.TotalOnBasePercentage);
}
public void GetTeamsStatsByYearReturnsEnumerableTeamsStats()
{
var firstTeam = new TeamStats
{
TeamId = "SEA",
YearId = 2000
};
var secondTeam = new TeamStats
{
TeamId = "NYY",
YearId = 2000
};
var expectedRecord = new List <TeamStats>()
{
firstTeam,
secondTeam
};
_teamsService.Setup(mockTeamsService => mockTeamsService.GetTeamStatsByYear(firstTeam.YearId)).Returns(expectedRecord);
var actualReturn = _controller.GetTeamStatsByYear(firstTeam.YearId);
Assert.That(actualReturn.ElementAt(0), Is.EqualTo(firstTeam));
Assert.That(actualReturn.ElementAt(1), Is.EqualTo(secondTeam));
}
public ItemHttpResponse <TeamWithTournament> InsertTeam(Team team)
{
if (ModelState.IsValid)
{
var teamStats = new TeamStats {
Draws = 0, Loses = 0, Points = 0, Recived = 0, RedCard = 0, Scored = 0, Wins = 0, YellowCard = 0
};
var newTeamStats = _dbContext.TeamStats.Add(teamStats);
_dbContext.SaveChanges();
team.TeamStatsId = newTeamStats.TeamStatsId;
var insertedTeam = _dbContext.Teams.Add(team);
_dbContext.SaveChanges();
var teams = _dbContext.Teams.ToList();
var result = new List <TeamWithTournament>();
foreach (var teamFromDb in teams)
{
var tournament = _dbContext.Tournaments.Where(t => t.TournamentId == teamFromDb.TournamentId).FirstOrDefault();
result.Add(new TeamWithTournament {
Team = teamFromDb, Tournament = tournament
});
}
return(new ItemHttpResponse <TeamWithTournament>(result, HttpStatusCode.OK));
}
return(new ItemHttpResponse <TeamWithTournament>(null, HttpStatusCode.BadRequest));
}
/*
* static IEnumerable<CupTable> Standings(IEnumerable<CupGame> cupGames) =>
* cupGames.GroupBy(x => x.Season)
* .ToLookup(
* year => year.Key,
* year => new CupTable(year).ToList()
* );
*/
private static void ShowStats(TeamStats utd, TeamStats weds)
{
Console.WriteLine($"{utd.Name} wins:{utd.Wins}");
Console.WriteLine($"{weds.Name} wins:{weds.Wins}");
Console.WriteLine($"{utd.Name} goals:{utd.Goals}");
Console.WriteLine($"{weds.Name} goals:{weds.Goals}");
Console.WriteLine($"{utd.Name} Conceded:{utd.Conceded}");
Console.WriteLine($"{weds.Name} Conceded:{weds.Conceded}");
Console.WriteLine($"{utd.Name} c/sheets:{utd.CleanSheets}");
Console.WriteLine($"{weds.Name} c/sheets:{weds.CleanSheets}");
Console.WriteLine($"{utd.Name} lost:{utd.Losses}");
Console.WriteLine($"{weds.Name} lost:{weds.Losses}");
Console.WriteLine($"{utd.Name} drawn:{utd.Draws}");
Console.WriteLine($"{weds.Name} drawn:{weds.Draws}");
Console.WriteLine($"{utd.Name} won:{utd.CompetitionWins}");
Console.WriteLine($"{weds.Name} won:{weds.CompetitionWins}");
Console.WriteLine($"{utd.Name} runner up:{utd.RunnersUp}");
Console.WriteLine($"{weds.Name} runner up:{weds.RunnersUp}");
Console.WriteLine($"{utd.Name} years:{utd.Years}");
Console.WriteLine($"{weds.Name} years:{weds.Years}");
}
/// <summary>Calculates the metrics of a player's performance.</summary>
/// <param name="r">
/// The SQLite DataRow containing the player's box score. Should be the result of an INNER JOIN'ed query between
/// PlayerResults and GameResults.
/// </param>
public void CalcMetrics(DataRow r)
{
var bs = new TeamBoxScore(r, null);
var ts = new TeamStats(TeamID);
var tsopp = new TeamStats(OppTeamID);
var team1ID = ParseCell.GetInt32(r, "Team1ID");
var team2ID = ParseCell.GetInt32(r, "Team2ID");
if (TeamID == team1ID)
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref ts, ref tsopp);
}
else
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref tsopp, ref ts);
}
var ps = new PlayerStats {
ID = PlayerID
};
ps.AddBoxScore(this, bs.IsPlayoff);
ps.CalcMetrics(ts, tsopp, new TeamStats(-1), GmScOnly: true);
GmSc = ps.Metrics["GmSc"];
GmScE = ps.Metrics["GmScE"];
}
/// <summary>Calculates the metrics of a player's performance.</summary>
/// <param name="bs">The game's box score from which to calculate the metrics.</param>
public void CalcMetrics(TeamBoxScore bs)
{
var ts = new TeamStats(TeamID);
var tsopp = new TeamStats(OppTeamID);
var team1ID = bs.Team1ID;
if (TeamID == team1ID)
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref ts, ref tsopp);
}
else
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref tsopp, ref ts);
}
var ps = new PlayerStats {
ID = PlayerID
};
ps.AddBoxScore(this, bs.IsPlayoff);
ps.CalcMetrics(ts, tsopp, new TeamStats(-1), GmScOnly: true);
GmSc = ps.Metrics["GmSc"];
GmScE = ps.Metrics["GmScE"];
}
static void AssertEmptyTeamStats(TeamStats teamStats)
{
Assert.IsNotNull(teamStats);
Assert.AreEqual(DateTime.Now.Year, teamStats.Year);
Assert.AreEqual(0, teamStats.Wins);
Assert.AreEqual(0, teamStats.Losses);
CollectionAssert.AreEqual(new List <int> {
DateTime.Now.Year
}, teamStats.Seasons);
Assert.IsNotNull(teamStats.PlayerYearStats);
Assert.IsFalse(teamStats.PlayerYearStats.Any());
Assert.AreEqual(0, teamStats.TotalAtBats);
Assert.AreEqual(0, teamStats.TotalRuns);
Assert.AreEqual(0, teamStats.TotalHits);
Assert.AreEqual(0, teamStats.TotalDoubles);
Assert.AreEqual(0, teamStats.TotalTriples);
Assert.AreEqual(0, teamStats.TotalHomeRuns);
Assert.AreEqual(0, teamStats.TotalRunsBattedIn);
Assert.AreEqual(0, teamStats.TotalWalks);
Assert.AreEqual(0, teamStats.TotalStrikeOuts);
Assert.AreEqual(0, teamStats.TotalAverage);
Assert.AreEqual(0, teamStats.TotalOnBasePercentage);
}
public async Task <TeamWithStatsDTO> Handle(UpdateTeamStatsCommand request, CancellationToken cancellationToken)
{
Team tm = await _context.Teams.Where(ch => ch.TeamId == request.Id).FirstOrDefaultAsync(cancellationToken: cancellationToken);
TeamStats tmStats = tm.Stats;
tmStats = new TeamStats
{
BombsTotal = request.BombsTotal ?? tmStats.BombsTotal,
EloRating = request.EloRating ?? tmStats.EloRating,
GamesTotal = request.GamesTotal ?? tmStats.GamesTotal,
GamesWon = request.GamesWon ?? tmStats.GamesWon,
GrandTichuCallsTotal = request.GrandTichuCallsTotal ?? tmStats.GrandTichuCallsTotal,
GrandTichuCallsWon = request.GrandTichuCallsWon ?? tmStats.GrandTichuCallsWon,
HighCardsTotal = request.HighCardsTotal ?? tmStats.HighCardsTotal,
OpponentsHighCardsTotal = request.OpponentsHighCardsTotal ?? tmStats.OpponentsHighCardsTotal,
OpponentsBombsTotal = request.OpponentsBombsTotal ?? tmStats.OpponentsBombsTotal,
TichuCallsWon = request.TichuCallsWon ?? tmStats.TichuCallsWon,
RoundsTotal = request.RoundsTotal ?? tmStats.RoundsTotal,
RoundsDrawn = request.RoundsDrawn ?? tmStats.RoundsDrawn,
RoundsWon = request.RoundsWon ?? tmStats.RoundsWon,
PointsWon = request.PointsWon ?? tmStats.PointsWon,
TichuCallsTotal = request.TichuCallsTotal ?? tmStats.TichuCallsTotal,
Id = tmStats.Id,
Team = tmStats.Team,
TeamId = tmStats.TeamId
};
await _context.SaveChangesAsync(cancellationToken);
return(_mapper.Map <TeamWithStatsDTO>(tm));
}
// Start is called before the first frame update
void Start()
{
gameManager = FindObjectOfType <GameManager>();
gameSpeedController = FindObjectOfType <GameSpeedController>();
switch (teamBlack.GetTeam())
{
case TeamName.BlackTeam:
teamAStats = ScoreKeeper.GetBlackTeamStats();
teamBStats = ScoreKeeper.GetRedTeamStats();
break;
case TeamName.RedTeam:
teamAStats = ScoreKeeper.GetRedTeamStats();
teamBStats = ScoreKeeper.GetBlackTeamStats();
break;
}
teamAStats = ScoreKeeper.GetBlackTeamStats();
teamBStats = ScoreKeeper.GetRedTeamStats();
//The gameSpeedController no longer uses this property. I am not hooking this up because AIs are no longer under development
//gameSpeedController.speed = testSpeed;
StartNewTest();
}
protected override void OnReset()
{
base.OnReset();
Winners = new PvPTeam[0];
TeamStats.Clear();
}
public TimeViewModel(TeamStats time)
{
NumeroDragoes = time.DragonKills;
NumeroBaroes = time.BaronKills;
NumeroArautos = time.RiftHeraldKills;
NumeroInibidores = time.InhibitorKills;
NumeroTorres = time.TowerKills;
}
public override void SetUp()
{
base.SetUp();
player = new Player(A.World.Build(), "Test", 75, 75, 75);
team1 = A.Team.WithPlayers(player).Build();
team2 = A.Team.Build();
stats = new TeamStats(team1);
}
public TeamStatsRow(
TeamStats ts,
Dictionary <int, PlayerStats> pst,
Dictionary <int, Dictionary <string, TeamStats> > splitTeamStats,
bool playoffs = false)
: this(ts, splitTeamStats, playoffs)
{
CalculateTotalContracts(pst);
CalculatePlayerCounts(pst);
}
private void AssertGetTeamsStatsReturnsStats(Teams expectedTeam)
{
var expectedTeamStats = new TeamStats();
_mockMapper.Setup(mockTeamsMapper => mockTeamsMapper.Map(expectedTeam)).Returns(expectedTeamStats);
var actualTeams = _service.GetTeamStats(expectedTeam.TeamId);
Assert.That(actualTeams.ElementAt(0), Is.EqualTo(expectedTeamStats));
}
public TeamStatsRow(TeamStats ts, Dictionary <int, Dictionary <string, TeamStats> > splitTeamStats, bool playoffs = false)
: this(ts, playoffs)
{
DivW = splitTeamStats[ID]["Division"].Record[0];
DivL = splitTeamStats[ID]["Division"].Record[1];
ConfW = splitTeamStats[ID]["Conference"].Record[0];
ConfL = splitTeamStats[ID]["Conference"].Record[1];
L10W = splitTeamStats[ID]["Last 10"].Record[0];
L10L = splitTeamStats[ID]["Last 10"].Record[1];
}
/// <summary>
/// Updates the team statistics from the fixtures/matches that have just been played
/// </summary>
/// <param name="fixtures">List of fixture objects to update</param>
public void UpdateMatchStats(List <Fixture> fixtures)
{
const int POINTS_WON = 3;
const int POINTS_DRAWN = 1;
TeamAdapter ta = new TeamAdapter();
foreach (Fixture fixture in fixtures)
{
TeamStats[] stats = new TeamStats[2];
for (int t = 0; t <= 1; t++)
{
stats[t] = ta.GetTeam(fixture.TeamIDs[t]).SeasonStatistics;
stats[t].GamesPlayed++;
stats[t].GoalsScored += fixture.Score[t];
stats[t].GoalsConceded += fixture.Score[1 - t];
}
if (fixture.Score[0] == fixture.Score[1])
{
for (int t = 0; t <= 1; t++)
{
stats[t].Drawn += 1;
stats[t].Points += POINTS_DRAWN;
}
}
else
{
int WinningTeam = -1;
int LosingTeam = -1;
if (fixture.Score[0] > fixture.Score[1])
{
WinningTeam = 0;
LosingTeam = 1;
}
else
{
WinningTeam = 1;
LosingTeam = 0;
}
stats[WinningTeam].Won += 1;
stats[LosingTeam].Lost += 1;
stats[WinningTeam].Points += POINTS_WON;
}
for (int t = 0; t <= 1; t++)
{
ta.UpdateTeamSeasonStatistics(fixture.TeamIDs[t], stats[t]);
}
}
}
/// <summary>
/// A player has died. Internal method to update the stats.
/// </summary>
/// <param name="attacker">The player that did the attacking.</param>
/// <param name="victim">The player that died.</param>
private void ReportDeathInternal(GameObject attacker, GameObject victim)
{
// Don't continue to add to the score if the game is over.
if (m_GameOver)
{
return;
}
// Health health = attacker.GetComponent<Health>();
// health.CurrentHealth += 50f;
// if (health.CurrentHealth > 100f) {
// health.CurrentHealth = 100f;
// }
TeamStats teamStats;
// The attacker gets a kill as long as it wasn't a suicide.
if (attacker != victim && attacker != null)
{
if (m_PlayerTeamStatMap.TryGetValue(attacker, out teamStats))
{
teamStats.AddKill(attacker);
// Check for a new leader.
if (m_Leader != teamStats)
{
if (teamStats.Kills > m_Leader.Kills)
{
m_Leader = teamStats;
}
}
// The local player will always be on team 0.
if (teamStats.TeamIndex != 0 && m_NonLocalPlayerLeader != teamStats)
{
if (teamStats.Kills > m_NonLocalPlayerLeader.Kills)
{
m_NonLocalPlayerLeader = teamStats;
}
}
}
}
// The victim gets a death.
if (m_PlayerTeamStatMap.TryGetValue(victim, out teamStats))
{
teamStats.AddDeath(victim);
}
EventHandler.ExecuteEvent("OnScoreChange");
// // The leader won if they reach the winning kill count.
// if (m_Leader.Kills >= (DeathmatchManager.TeamGame ? m_TeamKillsToWin : m_FFAKillsToWin)) {
// EventHandler.ExecuteEvent<bool>("OnGameOver", m_Leader == m_TeamStats[0]);
// m_GameOver = true;
// }
}
protected override int GetLabelHue(int index, int pageIndex, KeyValuePair <PlayerMobile, PvPProfileHistoryEntry> entry)
{
int teamcolor = TextHue;
if (TeamStats.ContainsKey(entry.Key))
{
teamcolor = TeamStats[entry.Key].Color;
}
return(entry.Key != null ? (entry.Key == User ? HighlightHue : teamcolor) : ErrorHue);
}
public void MapCopiesDataFromTeamsToTeamStats()
{
Teams teams = GenerateTeamsWithoutNullValues();
TeamStats teamStats = _mapper.Map(teams);
AssertThatEachElementIsEqualWithoutNullValues(teams, teamStats);
Teams teamsWithNull = GenerateTeamsWithNullValues();
TeamStats teamsStatsWithNull = _mapper.Map(teamsWithNull);
AssertThatEachElementIsEqualWithNullValues(teamsWithNull, teamsStatsWithNull);
}
private void AssertThatEachElementIsEqualWithoutNullValues(Teams teams, TeamStats teamStats)
{
Assert.That(teamStats.YearId, Is.EqualTo(teams.YearId));
Assert.That(teamStats.LgId, Is.EqualTo(teams.LgId));
Assert.That(teamStats.TeamId, Is.EqualTo(teams.TeamId));
Assert.That(teamStats.FranchId, Is.EqualTo(teams.FranchId));
Assert.That(teamStats.DivId, Is.EqualTo(teams.DivId));
Assert.That(teamStats.Rank, Is.EqualTo(teams.Rank));
Assert.That(teamStats.G, Is.EqualTo(teams.G));
Assert.That(teamStats.Ghome, Is.EqualTo(teams.Ghome));
Assert.That(teamStats.W, Is.EqualTo(teams.W));
Assert.That(teamStats.L, Is.EqualTo(teams.L));
Assert.That(teamStats.DivWin, Is.EqualTo(teams.DivWin));
Assert.That(teamStats.Wcwin, Is.EqualTo(teams.Wcwin));
Assert.That(teamStats.LgWin, Is.EqualTo(teams.LgWin));
Assert.That(teamStats.Wswin, Is.EqualTo(teams.Wswin));
Assert.That(teamStats.R, Is.EqualTo(teams.R));
Assert.That(teamStats.Ab, Is.EqualTo(teams.Ab));
Assert.That(teamStats.H, Is.EqualTo(teams.H));
Assert.That(teamStats.X2b, Is.EqualTo(teams.X2b));
Assert.That(teamStats.X3b, Is.EqualTo(teams.X3b));
Assert.That(teamStats.Hr, Is.EqualTo(teams.Hr));
Assert.That(teamStats.Bb, Is.EqualTo(teams.Bb));
Assert.That(teamStats.So, Is.EqualTo(teams.So));
Assert.That(teamStats.Sb, Is.EqualTo(teams.Sb));
Assert.That(teamStats.Cs, Is.EqualTo(teams.Cs));
Assert.That(teamStats.Hbp, Is.EqualTo(teams.Hbp));
Assert.That(teamStats.Sf, Is.EqualTo(teams.Sf));
Assert.That(teamStats.Ra, Is.EqualTo(teams.Ra));
Assert.That(teamStats.Er, Is.EqualTo(teams.Er));
var localEra = teams.Era / 100 ?? 0;
Assert.That(teamStats.Era, Is.EqualTo(Math.Round(localEra, 2)));
Assert.That(teamStats.Cg, Is.EqualTo(teams.Cg));
Assert.That(teamStats.Sho, Is.EqualTo(teams.Sho));
Assert.That(teamStats.Sv, Is.EqualTo(teams.Sv));
Assert.That(teamStats.Ipouts, Is.EqualTo(teams.Ipouts));
Assert.That(teamStats.Ha, Is.EqualTo(teams.Ha));
Assert.That(teamStats.Hra, Is.EqualTo(teams.Hra));
Assert.That(teamStats.Bba, Is.EqualTo(teams.Bba));
Assert.That(teamStats.Soa, Is.EqualTo(teams.Soa));
Assert.That(teamStats.E, Is.EqualTo(teams.E));
Assert.That(teamStats.Dp, Is.EqualTo(teams.Dp));
Assert.That(teamStats.Fp, Is.EqualTo(teams.Fp));
Assert.That(teamStats.Name, Is.EqualTo(teams.Name));
Assert.That(teamStats.Park, Is.EqualTo(teams.Park));
Assert.That(teamStats.Attendance, Is.EqualTo(teams.Attendance));
Assert.That(teamStats.Bpf, Is.EqualTo(teams.Bpf));
Assert.That(teamStats.Ppf, Is.EqualTo(teams.Ppf));
Assert.That(teamStats.TeamIdbr, Is.EqualTo(teams.TeamIdbr));
Assert.That(teamStats.TeamIdlahman45, Is.EqualTo(teams.TeamIdlahman45));
Assert.That(teamStats.TeamIdretro, Is.EqualTo(teams.TeamIdretro));
}
public void Initialize(JObject jGame, string gameId, string home_away) {
Passers = getPassing(jGame, gameId, home_away);
Rushers = getRushing(jGame, gameId, home_away);
Receivers = getReceiving(jGame, gameId, home_away);
Fumblers = getFumbling(jGame, gameId, home_away);
Defenders = getDefending(jGame, gameId, home_away);
Kickers = getKicking(jGame, gameId, home_away);
Punters = getPunting(jGame, gameId, home_away);
KickReturners = getKickret(jGame, gameId, home_away);
PuntReturners = getPuntret(jGame, gameId, home_away);
TeamStats = getTeamStats(jGame, gameId, home_away);
}
public void CorrectStanding_ShouldWork_TeamsWithAndWithoutStanding()
{
// Standing should remain unchanged.
var teams = new MockData().LeagueStandings.ExtractTeamStats("2010-11");
var actual = TeamStats.CorrectStanding(teams).ToList();
Assert.Contains(actual, p => p.Standing == 0);
Assert.Contains(actual, p => p.Standing == 2);
Assert.Contains(actual, p => p.Standing == 3);
}
public void Velocity_WhenTotalCommitsAndActiveDevelopersNonZero_ShouldReturnDivisionToTwoDecimalPlaces()
{
// arrange
var sut = new TeamStats {
TotalCommits = 1, ActiveDevelopers = 3
};
// act
var actual = sut.Velocity;
// assert
actual.Should().Be(0.33);
}
/// <summary>Downloads and imports the real NBA stats of a specific team and its players.</summary>
/// <param name="teamAbbr">The team name-abbreviation KeyValuePair.</param>
/// <param name="ts">The resulting team stats instance.</param>
/// <param name="tsopp">The opposing team stats instance.</param>
/// <param name="pst">The resulting player stats dictionary.</param>
public static void ImportRealStats(
KeyValuePair <string, string> teamAbbr, out TeamStats ts, out TeamStats tsopp, out Dictionary <int, PlayerStats> pst)
{
string[] recordparts;
var ds = getSeasonTeamStats(
@"http://www.basketball-reference.com/teams/" + teamAbbr.Value + @"/2014.html", out recordparts);
teamStatsFromDataTable(ds.Tables[0], teamAbbr.Key, recordparts, out ts, out tsopp);
ds = getPlayerStats(@"http://www.basketball-reference.com/teams/" + teamAbbr.Value + @"/2014.html");
playerStatsFromDataSet(ds, ts.ID, out pst);
}
/// <summary>Creates the team and opposing team stats instances using data from the downloaded DataTable.</summary>
/// <param name="dt">The DataTable.</param>
/// <param name="name">The name of the team.</param>
/// <param name="recordparts">The parts of the team's record string.</param>
/// <param name="ts">The resulting team stats instance.</param>
/// <param name="tsopp">The resulting opposing team stats instance.</param>
private static void teamStatsFromDataTable(
DataTable dt, string name, string[] recordparts, out TeamStats ts, out TeamStats tsopp)
{
var teamID = MainWindow.RealTST.Single(pair => pair.Value.Name == name).Key;
ts = new TeamStats(teamID, name);
tsopp = new TeamStats(teamID, name);
tsopp.Record[1] = ts.Record[0] = Convert.ToByte(recordparts[0]);
tsopp.Record[0] = ts.Record[1] = Convert.ToByte(recordparts[1]);
var tr = dt.Rows[0];
var toppr = dt.Rows[2];
ts.Totals[TAbbrT.MINS] = (ushort)(ParseCell.GetUInt16(tr, "MP") / 5);
ts.Totals[TAbbrT.FGM] = ParseCell.GetUInt16(tr, "FG");
ts.Totals[TAbbrT.FGA] = ParseCell.GetUInt16(tr, "FGA");
ts.Totals[TAbbrT.TPM] = ParseCell.GetUInt16(tr, "3P");
ts.Totals[TAbbrT.TPA] = ParseCell.GetUInt16(tr, "3PA");
ts.Totals[TAbbrT.FTM] = ParseCell.GetUInt16(tr, "FT");
ts.Totals[TAbbrT.FTA] = ParseCell.GetUInt16(tr, "FTA");
ts.Totals[TAbbrT.OREB] = ParseCell.GetUInt16(tr, "ORB");
ts.Totals[TAbbrT.DREB] = ParseCell.GetUInt16(tr, "DRB");
ts.Totals[TAbbrT.AST] = ParseCell.GetUInt16(tr, "AST");
ts.Totals[TAbbrT.STL] = ParseCell.GetUInt16(tr, "STL");
ts.Totals[TAbbrT.BLK] = ParseCell.GetUInt16(tr, "BLK");
ts.Totals[TAbbrT.TOS] = ParseCell.GetUInt16(tr, "TOV");
ts.Totals[TAbbrT.FOUL] = ParseCell.GetUInt16(tr, "PF");
ts.Totals[TAbbrT.PF] = ParseCell.GetUInt16(tr, "PTS");
ts.Totals[TAbbrT.PA] = ParseCell.GetUInt16(toppr, "PTS");
ts.CalcAvg();
tsopp.Totals[TAbbrT.MINS] = (ushort)(ParseCell.GetUInt16(toppr, "MP") / 5);
tsopp.Totals[TAbbrT.FGM] = ParseCell.GetUInt16(toppr, "FG");
tsopp.Totals[TAbbrT.FGA] = ParseCell.GetUInt16(toppr, "FGA");
tsopp.Totals[TAbbrT.TPM] = ParseCell.GetUInt16(toppr, "3P");
tsopp.Totals[TAbbrT.TPA] = ParseCell.GetUInt16(toppr, "3PA");
tsopp.Totals[TAbbrT.FTM] = ParseCell.GetUInt16(toppr, "FT");
tsopp.Totals[TAbbrT.FTA] = ParseCell.GetUInt16(toppr, "FTA");
tsopp.Totals[TAbbrT.OREB] = ParseCell.GetUInt16(toppr, "ORB");
tsopp.Totals[TAbbrT.DREB] = ParseCell.GetUInt16(toppr, "DRB");
tsopp.Totals[TAbbrT.AST] = ParseCell.GetUInt16(toppr, "AST");
tsopp.Totals[TAbbrT.STL] = ParseCell.GetUInt16(toppr, "STL");
tsopp.Totals[TAbbrT.BLK] = ParseCell.GetUInt16(toppr, "BLK");
tsopp.Totals[TAbbrT.TOS] = ParseCell.GetUInt16(toppr, "TOV");
tsopp.Totals[TAbbrT.FOUL] = ParseCell.GetUInt16(toppr, "PF");
tsopp.Totals[TAbbrT.PF] = ParseCell.GetUInt16(toppr, "PTS");
tsopp.Totals[TAbbrT.PA] = ParseCell.GetUInt16(tr, "PTS");
tsopp.CalcAvg();
}
private void AssertGetTeamsStatsReturnsStatsWithDuplicateId(Teams firstEntry, Teams secondEntry)
{
var firstEntryStats = new TeamStats();
var secondEntryStats = new TeamStats();
_mockMapper.Setup(mockTeamsMapper => mockTeamsMapper.Map(firstEntry)).Returns(firstEntryStats);
_mockMapper.Setup(mockTeamsMapper => mockTeamsMapper.Map(secondEntry)).Returns(secondEntryStats);
var actualTeams = _service.GetTeamStats(firstEntry.TeamId);
Assert.That(actualTeams.ElementAt(0), Is.EqualTo(firstEntryStats));
Assert.That(actualTeams.ElementAt(1), Is.EqualTo(secondEntryStats));
}
public void CorrectStanding_ShouldWork_TeamsWithoutStanding()
{
// Standing should get adjusted.
var teams = new MockData().LeagueStandings.ExtractTeamStats("2010-11");
var tmp = TeamStats.CorrectStanding(teams.Where(t => t.Standing == 0));
List <TeamStats> actual = tmp.ToList();
Assert.Equal(1, actual[0].Standing);
Assert.Equal(2, actual[1].Standing);
}
private void AssertGetTeamsStatsByYearReturnsStats(Teams firstEntry, Teams secondEntry)
{
var firstEntryByYear = new TeamStats();
var secondEntryByYear = new TeamStats();
_mockMapper.Setup(mockTeamsMapper => mockTeamsMapper.Map(firstEntry)).Returns(firstEntryByYear);
_mockMapper.Setup(mockTeamsMapper => mockTeamsMapper.Map(secondEntry)).Returns(secondEntryByYear);
var actualTeams = _service.GetTeamStatsByYear(firstEntry.YearId);
Assert.That(actualTeams.ElementAt(0), Is.EqualTo(firstEntryByYear));
Assert.That(actualTeams.ElementAt(1), Is.EqualTo(secondEntryByYear));
}
public TeamWindow(TeamStats team, List <string> seasons, string selectedSeason, List <TeamData> teamData)
{
InitializeComponent();
teamID = team.TeamID;
teamName = team.TeamName;
TeamData = teamData;
MainLabel.Content = teamName + " Team Rooster";
BindSeasons(seasons, selectedSeason);
}
public void ShouldConsiderHigherGoalsScoredAsHigherPositionWhenPointsAndGoalDifferenceAreEqual()
{
var stats1 = new TeamStats(team1);
var stats2 = new TeamStats(team2);
stats1.ApplyResult(A.MatchResult.ForTeams(team1, A.Team.Build()).WithScore(1, 2).Build());
stats2.ApplyResult(A.MatchResult.ForTeams(team2, A.Team.Build()).WithScore(2, 3).Build());
Assert.That(stats1, Is.LessThan(stats2));
}
/// <summary>
/// Sets up the scoreboard according to the type of game being played
/// </summary>
/// <param name="gameMode">The current game mode being played.</param>
private void Initialize(GameMode gameMode)
{
//ranks = new Dictionary<string, int>();
//initialRanks = new Dictionary<string, int>();
playersWhoRankedUp = new List<string>();
RefreshRanks(); //Load ranks for current rank tracking
initialRanks = LoadRanks(this.initialRanks);
LoadHeader(gameMode);
team1 = new Dictionary<string, Score>();
team1stats = new TeamStats();
team1stats.assists = 0;
team1stats.deaths = 0;
team1stats.kills = 0;
team1stats.objectives = 0;
team1stats.roundWins = 0;
customBlue.R = 48;
customBlue.G = 75;
customBlue.B = 255;
customBlue.A = 255;
if (gameMode != GameMode.DEATHMATCH)
{
team2 = new Dictionary<string, Score>();
team2stats = new TeamStats();
team2stats.assists = 0;
team2stats.deaths = 0;
team2stats.kills = 0;
team2stats.objectives = 0;
team2stats.roundWins = 0;
}
line = new Texture2D(ServiceManager.Game.GraphicsDevice, 1, 1);
line.SetData<Color>(new Color[] { Color.White });
}
private TeamStats getTeamStats(JObject jGame, string gameId, string home_away) {
TeamStats teamStats = null;
JObject teamStatsJson = (JObject)jGame[gameId][home_away]["stats"]["team"];
teamStats = new TeamStats(
(int)teamStatsJson["totfd"],
(int)teamStatsJson["totyds"],
(int)teamStatsJson["pyds"],
(int)teamStatsJson["ryds"],
(int)teamStatsJson["pen"],
(int)teamStatsJson["penyds"],
(int)teamStatsJson["trnovr"],
(int)teamStatsJson["pt"],
(int)teamStatsJson["ptyds"],
(int)teamStatsJson["ptavg"],
(string)teamStatsJson["top"]);
return teamStats;
}
/// <summary>
/// Draws a dictionary based on sorted values
/// </summary>
/// <param name="team1"></param>
/// <param name="i"></param>
/// <param name="h"></param>
/// <param name="rect"></param>
private void DrawSortedTeam(Dictionary<string, Score> team, ref int height_modifier, int height, Rectangle rect, TeamStats stats)
{
List<KeyValuePair<string, Score>> myList = new List<KeyValuePair<string, Score>>(team);
myList.Sort((firstPair, nextPair) =>
{
return firstPair.Value.CompareTo(nextPair.Value);
});
Rectangle playerRect = new Rectangle(rect.X + x_offset, rect.Y + (height * height_modifier), rect.Width, height);
foreach (KeyValuePair<string, Score> s in myList)
{
if (!team1.ContainsKey(s.Key) && !team2.ContainsKey(s.Key))
continue;
if (playersWhoRankedUp.Count != 0)
{
if (playersWhoRankedUp.Contains(s.Key))
DrawStrings(GetValues(s.Key), playerRect, Color.Yellow, false);
else
DrawStrings(GetValues(s.Key), playerRect, GetPlayerByName(s.Key).Color, false);
}
else
{
DrawStrings(GetValues(s.Key), playerRect, GetPlayerByName(s.Key).Color, false);
}
++height_modifier;
playerRect.Y = rect.Y + (height * height_modifier);
}
if (team2 != null)
{
string[] totalTeamStats;
if (mode == GameMode.TEAMDEATHMATCH)
{
totalTeamStats = new string [] {"Total",
" ",
stats.kills.ToString(),
stats.deaths.ToString(),
stats.assists.ToString()};
}
else
{
totalTeamStats = new string [] {"Total",
" ",
stats.kills.ToString(),
stats.deaths.ToString(),
stats.assists.ToString(),
stats.objectives.ToString()};
}
DrawStrings(totalTeamStats, playerRect, Color.White, false);
}
}
public void ShouldConsiderHigherPointsAsHigherPosition()
{
var stats1 = new TeamStats(team1);
var stats2 = new TeamStats(team2);
stats1.ApplyResult(A.MatchResult.ForTeams(team1, A.Team.Build()).WithScore(1, 0).Build());
stats2.ApplyResult(A.MatchResult.ForTeams(team2, A.Team.Build()).WithScore(0, 0).Build());
Assert.That(stats1, Is.GreaterThan(stats2));
}
