/// <summary>
/// Creates the player stats instances using data from the downloaded DataSet.
/// </summary>
/// <param name="ds">The DataSet.</param>
/// <param name="teamID">The player's team.</param>
/// <param name="pst">The player stats dictionary.</param>
/// <exception cref="System.Exception">Don't recognize the position </exception>
private static void playerStatsFromDataSet(DataSet ds, int teamID, out Dictionary<int, PlayerStats> pst)
{
var pstnames = new Dictionary<string, PlayerStats>();
DataTable dt = ds.Tables["roster"];
foreach (DataRow r in dt.Rows)
{
Position position1;
Position position2;
switch (r["Pos"].ToString())
{
case "C":
position1 = Position.C;
position2 = Position.None;
break;
case "G":
position1 = Position.PG;
position2 = Position.SG;
break;
case "F":
position1 = Position.SF;
position2 = Position.PF;
break;
case "G-F":
position1 = Position.SG;
position2 = Position.SF;
break;
case "F-G":
position1 = Position.SF;
position2 = Position.SG;
break;
case "F-C":
position1 = Position.PF;
position2 = Position.C;
break;
case "C-F":
position1 = Position.C;
position2 = Position.PF;
break;
case "PG":
position1 = Position.PG;
position2 = Position.None;
break;
case "SG":
position1 = Position.SG;
position2 = Position.None;
break;
case "SF":
position1 = Position.SF;
position2 = Position.None;
break;
case "PF":
position1 = Position.PF;
position2 = Position.None;
break;
default:
throw (new Exception("Don't recognize the position " + r["Pos"]));
}
var ps =
new PlayerStats(new Player(pstnames.Count, teamID, r["Player"].ToString().Split(' ')[1],
r["Player"].ToString().Split(' ')[0], position1, position2));
pstnames.Add(r["Player"].ToString(), ps);
}
dt = ds.Tables["totals"];
foreach (DataRow r in dt.Rows)
{
string name = r["Player"].ToString();
pstnames[name].Totals[PAbbr.GP] = ParseCell.GetUInt16(r, "G");
pstnames[name].Totals[PAbbr.GS] = ParseCell.GetUInt16(r, "GS");
pstnames[name].Totals[PAbbr.MINS] = ParseCell.GetUInt16(r, "MP");
pstnames[name].Totals[PAbbr.FGM] = ParseCell.GetUInt16(r, "FG");
pstnames[name].Totals[PAbbr.FGA] = ParseCell.GetUInt16(r, "FGA");
pstnames[name].Totals[PAbbr.TPM] = ParseCell.GetUInt16(r, "3P");
pstnames[name].Totals[PAbbr.TPA] = ParseCell.GetUInt16(r, "3PA");
pstnames[name].Totals[PAbbr.FTM] = ParseCell.GetUInt16(r, "FT");
pstnames[name].Totals[PAbbr.FTA] = ParseCell.GetUInt16(r, "FTA");
pstnames[name].Totals[PAbbr.OREB] = ParseCell.GetUInt16(r, "ORB");
pstnames[name].Totals[PAbbr.DREB] = ParseCell.GetUInt16(r, "DRB");
pstnames[name].Totals[PAbbr.AST] = ParseCell.GetUInt16(r, "AST");
pstnames[name].Totals[PAbbr.STL] = ParseCell.GetUInt16(r, "STL");
pstnames[name].Totals[PAbbr.BLK] = ParseCell.GetUInt16(r, "BLK");
pstnames[name].Totals[PAbbr.TOS] = ParseCell.GetUInt16(r, "TOV");
pstnames[name].Totals[PAbbr.FOUL] = ParseCell.GetUInt16(r, "PF");
pstnames[name].Totals[PAbbr.PTS] = ParseCell.GetUInt16(r, "PTS");
}
dt = ds.Tables["playoffs"];
try
{
foreach (DataRow r in dt.Rows)
{
string name = r["Player"].ToString();
pstnames[name].PlTotals[PAbbr.GP] += ParseCell.GetUInt16(r, "G");
//pstnames[name].pl_stats[p.GS] += NSTHelper.getUShort(r, "GS");
pstnames[name].PlTotals[PAbbr.MINS] += ParseCell.GetUInt16(r, "MP");
pstnames[name].PlTotals[PAbbr.FGM] += ParseCell.GetUInt16(r, "FG");
pstnames[name].PlTotals[PAbbr.FGA] += ParseCell.GetUInt16(r, "FGA");
pstnames[name].PlTotals[PAbbr.TPM] += ParseCell.GetUInt16(r, "3P");
pstnames[name].PlTotals[PAbbr.TPA] += ParseCell.GetUInt16(r, "3PA");
pstnames[name].PlTotals[PAbbr.FTM] += ParseCell.GetUInt16(r, "FT");
pstnames[name].PlTotals[PAbbr.FTA] += ParseCell.GetUInt16(r, "FTA");
pstnames[name].PlTotals[PAbbr.OREB] += ParseCell.GetUInt16(r, "ORB");
pstnames[name].PlTotals[PAbbr.DREB] += (ushort) (ParseCell.GetUInt16(r, "TRB") - ParseCell.GetUInt16(r, "ORB"));
pstnames[name].PlTotals[PAbbr.AST] += ParseCell.GetUInt16(r, "AST");
pstnames[name].PlTotals[PAbbr.STL] += ParseCell.GetUInt16(r, "STL");
pstnames[name].PlTotals[PAbbr.BLK] += ParseCell.GetUInt16(r, "BLK");
pstnames[name].PlTotals[PAbbr.TOS] += ParseCell.GetUInt16(r, "TOV");
pstnames[name].PlTotals[PAbbr.FOUL] += ParseCell.GetUInt16(r, "PF");
pstnames[name].PlTotals[PAbbr.PTS] += ParseCell.GetUInt16(r, "PTS");
pstnames[name].CalcAvg();
}
}
catch (Exception ex)
{
Console.WriteLine("Exception while trying to parse playoff table: " + ex.Message);
}
pst = new Dictionary<int, PlayerStats>();
foreach (var kvp in pstnames)
{
kvp.Value.ID = pst.Count;
pst.Add(pst.Count, kvp.Value);
}
}
/// <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"];
}
private static void importPlayerStats(
PlayerStats ps, Dictionary<string, string> redPlayerStats, NBA2KVersion nba2KVersion, bool playoffs)
{
var arr = !playoffs ? ps.Totals : ps.PlTotals;
arr[PAbbrT.GP] = Convert.ToUInt16(redPlayerStats["GamesP"]);
arr[PAbbrT.GS] = Convert.ToUInt16(redPlayerStats["GamesS"]);
arr[PAbbrT.MINS] = Convert.ToUInt16(redPlayerStats["Minutes"]);
arr[PAbbrT.PTS] = Convert.ToUInt16(redPlayerStats["Points"]);
arr[PAbbrT.DREB] = Convert.ToUInt16(redPlayerStats["DRebs"]);
arr[PAbbrT.OREB] = Convert.ToUInt16(redPlayerStats["ORebs"]);
arr[PAbbrT.AST] = Convert.ToUInt16(redPlayerStats["Assists"]);
arr[PAbbrT.STL] = Convert.ToUInt16(redPlayerStats["Steals"]);
arr[PAbbrT.BLK] = Convert.ToUInt16(redPlayerStats["Blocks"]);
arr[PAbbrT.TOS] = Convert.ToUInt16(redPlayerStats["TOs"]);
arr[PAbbrT.FOUL] = Convert.ToUInt16(redPlayerStats["Fouls"]);
arr[PAbbrT.FGM] = Convert.ToUInt16(redPlayerStats["FGMade"]);
arr[PAbbrT.FGA] = Convert.ToUInt16(redPlayerStats["FGAtt"]);
try
{
arr[PAbbrT.TPM] = Convert.ToUInt16(redPlayerStats["3PTMade"]);
arr[PAbbrT.TPA] = Convert.ToUInt16(redPlayerStats["3PTAtt"]);
}
catch (KeyNotFoundException)
{
arr[PAbbrT.TPM] = Convert.ToUInt16(redPlayerStats["TPTMade"]);
arr[PAbbrT.TPA] = Convert.ToUInt16(redPlayerStats["TPTAtt"]);
}
arr[PAbbrT.FTM] = Convert.ToUInt16(redPlayerStats["FTMade"]);
arr[PAbbrT.FTA] = Convert.ToUInt16(redPlayerStats["FTAtt"]);
if (nba2KVersion == NBA2KVersion.NBA2K12)
{
ps.IsAllStar = Convert.ToBoolean(Convert.ToInt32(redPlayerStats["IsAStar"]));
ps.IsNBAChampion = Convert.ToBoolean(Convert.ToInt32(redPlayerStats["IsChamp"]));
}
else if (nba2KVersion >= NBA2KVersion.NBA2K13)
{
ps.IsAllStar = Convert.ToBoolean(Convert.ToInt32(redPlayerStats["IsAllStar"]));
ps.IsNBAChampion = Convert.ToBoolean(Convert.ToInt32(redPlayerStats["IsNBAChamp"]));
}
}
/// <summary>Adds the player stats from a PlayerStats instance to the current stats.</summary>
/// <param name="ps">The PlayerStats instance.</param>
/// <param name="addBothToSeasonStats">
/// if set to <c>true</c>, both season and playoff stats will be added to the season stats.
/// </param>
public void AddPlayerStats(PlayerStats ps, bool addBothToSeasonStats = false)
{
if (!addBothToSeasonStats)
{
for (var i = 0; i < Totals.Length; i++)
{
Totals[i] += ps.Totals[i];
}
for (var i = 0; i < PlTotals.Length; i++)
{
PlTotals[i] += ps.PlTotals[i];
}
}
else
{
for (var i = 0; i < Totals.Length; i++)
{
Totals[i] += ps.Totals[i];
}
for (var i = 0; i < PlTotals.Length; i++)
{
Totals[i] += ps.PlTotals[i];
}
}
CalcAvg();
}
private bool doPlayer(PlayerStats ps)
{
if (ps.IsHidden)
{
return true;
}
var psr = new PlayerStatsRow(ps);
var plPSR = new PlayerStatsRow(ps, true);
if (psr.IsSigned)
{
if (!inCurrentFilter(_tst[psr.TeamF]))
{
return true;
}
psr.TeamFDisplay = _tst[psr.TeamF].DisplayName;
plPSR.TeamFDisplay = psr.TeamFDisplay;
}
else
{
if (_filterType != TeamFilter.League)
{
return true;
}
psr.TeamFDisplay = "- Free Agency -";
plPSR.TeamFDisplay = psr.TeamFDisplay;
}
_psrListSea.Add(psr);
_psrListPl.Add(plPSR);
return false;
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerStatsRow" /> class.
/// </summary>
/// <param name="ps">The PlayerStats instance.</param>
/// <param name="type">The type.</param>
/// <param name="group">The group.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the interface provided will show playoff stats.
/// </param>
public PlayerStatsRow(PlayerStats ps, string type, string group, bool playoffs = false)
: this(ps, type, playoffs)
{
Type = type;
Group = group;
}
/// <summary>
/// Calculates the league PerGame.
/// </summary>
/// <param name="playerStats">The player stats.</param>
/// <param name="teamStats">The team stats.</param>
/// <returns></returns>
public static PlayerStats CalculateLeagueAverages(Dictionary<int, PlayerStats> playerStats,
Dictionary<int, TeamStats> teamStats)
{
var lps = new PlayerStats(new Player(-1, -1, "League", "Averages", Position.None, Position.None));
foreach (int key in playerStats.Keys)
{
lps.AddPlayerStats(playerStats[key]);
}
var ls = new TeamStats(-2, "League");
for (int i = 0; i < teamStats.Count; i++)
{
ls.AddTeamStats(teamStats[i], Span.Season);
ls.AddTeamStats(teamStats[i], Span.Playoffs);
}
ls.CalcMetrics(ls);
ls.CalcMetrics(ls, true);
lps.CalcMetrics(ls, ls, ls, true);
lps.CalcMetrics(ls, ls, ls, true, playoffs: true);
var playerCount = (uint) playerStats.Count;
for (int i = 0; i < lps.Totals.Length; i++)
{
lps.Totals[i] /= playerCount;
lps.PlTotals[i] /= playerCount;
}
//ps.CalcAvg();
return lps;
}
/// <summary>
/// Gets the difference of a player's stat's value between the current and previous stats.
/// </summary>
/// <param name="newPS">The new player stats instance.</param>
/// <param name="oldPS">The old player stats instance.</param>
/// <param name="stat">The stat.</param>
/// <returns></returns>
private static ushort getDiff(PlayerStats newPS, PlayerStats oldPS, int stat, bool isPlayoff = false)
{
return !isPlayoff
? (ushort) (newPS.Totals[stat] - oldPS.Totals[stat])
: (ushort) (newPS.PlTotals[stat] - oldPS.PlTotals[stat]);
}
/// <summary>
/// Handles the SelectionChanged event of the cmbOppPlayer control.
/// Allows the user to change the opposing player, to whose stats the current player's stats will be compared.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">
/// The <see cref="SelectionChangedEventArgs" /> instance containing the event data.
/// </param>
private void cmbOppPlayer_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
if (cmbTeam.SelectedIndex == -1 || cmbOppTeam.SelectedIndex == -1 || cmbPlayer.SelectedIndex == -1 ||
cmbOppPlayer.SelectedIndex == -1)
{
dgvHTH.ItemsSource = null;
dgvHTHBoxScores.ItemsSource = null;
return;
}
}
catch
{
return;
}
dgvHTH.ItemsSource = null;
selectedOppPlayerID = ((KeyValuePair<int, string>) (cmbOppPlayer.SelectedItem)).Key;
var psrList = new ObservableCollection<PlayerStatsRow>();
_hthAllPBS = new List<PlayerBoxScore>();
if (_selectedPlayerID == selectedOppPlayerID)
{
return;
}
if (rbHTHStatsAnyone.IsChecked.GetValueOrDefault())
{
_psr.Type = _psr.FirstName + " " + _psr.LastName;
psrList.Add(_psr);
var gameIDs = new List<int>();
foreach (PlayerBoxScore cur in _pbsList)
{
_hthAllPBS.Add(cur);
gameIDs.Add(cur.GameID);
}
ParallelQuery<PlayerBoxScore> oppPBSList =
MainWindow.BSHist.AsParallel()
.Where(bse => bse.PBSList.Any(pbs => pbs.PlayerID == selectedOppPlayerID))
.Select(bse => bse.PBSList.Single(pbs => pbs.PlayerID == selectedOppPlayerID))
.Where(pbs => !pbs.IsOut);
foreach (PlayerBoxScore oppPBS in oppPBSList)
{
if (!gameIDs.Contains(oppPBS.GameID))
{
oppPBS.AddInfoFromTeamBoxScore(MainWindow.BSHist.Single(bse => bse.BS.ID == oppPBS.GameID).BS, MainWindow.TST);
_hthAllPBS.Add(oppPBS);
}
}
PlayerStats oppPS = MainWindow.PST[selectedOppPlayerID];
psrList.Add(new PlayerStatsRow(oppPS, oppPS.FirstName + " " + oppPS.LastName));
}
else
{
ParallelQuery<BoxScoreEntry> againstBSList =
MainWindow.BSHist.AsParallel()
.Where(
bse =>
_pbsList.Any(pbs => pbs.GameID == bse.BS.ID) &&
bse.PBSList.Any(pbs => pbs.PlayerID == selectedOppPlayerID && !pbs.IsOut));
var psOwn = new PlayerStats(_psr);
psOwn.ResetStats();
PlayerStats psOpp = MainWindow.PST[selectedOppPlayerID].DeepClone();
psOpp.ResetStats();
foreach (BoxScoreEntry bse in againstBSList)
{
PlayerBoxScore pbsOwn = bse.PBSList.Single(pbs => pbs.PlayerID == psOwn.ID);
pbsOwn.AddInfoFromTeamBoxScore(bse.BS, MainWindow.TST);
PlayerBoxScore pbsOpp = bse.PBSList.Single(pbs => pbs.PlayerID == psOpp.ID);
psOwn.AddBoxScore(pbsOwn);
psOpp.AddBoxScore(pbsOpp);
_hthAllPBS.Add(pbsOwn);
}
var psrOwn = new PlayerStatsRow(psOwn);
psrOwn.Type = psrOwn.FullNameGivenFirst;
psrList.Add(psrOwn);
var psrOpp = new PlayerStatsRow(psOpp);
psrOpp.Type = psrOpp.FullNameGivenFirst;
psrList.Add(psrOpp);
}
_hthAllPBS.Sort((pbs1, pbs2) => pbs2.RealDate.CompareTo(pbs1.RealDate));
dgvHTH.ItemsSource = psrList;
dgvHTHBoxScores.ItemsSource = _hthAllPBS;
}
/// <summary>
/// Creates a PlayerStats instance from the currently displayed information and stats.
/// </summary>
/// <returns></returns>
private PlayerStats createPlayerStatsFromCurrent()
{
if (cmbPosition2.SelectedItem == null)
{
cmbPosition2.SelectedItem = " ";
}
int teamF;
if (chkIsActive.IsChecked.GetValueOrDefault() == false)
{
teamF = -1;
}
else
{
teamF = GetTeamIDFromDisplayName(cmbTeam.SelectedItem.ToString());
if (teamF == -1)
{
var atw = new ComboChoiceWindow("Select the team to which to sign the player", _teams,
ComboChoiceWindow.Mode.OneTeam);
if (atw.ShowDialog() == true)
{
teamF = Misc.GetTeamIDFromDisplayName(MainWindow.TST, ComboChoiceWindow.UserChoice);
}
else
{
teamF = -1;
chkIsActive.IsChecked = false;
}
}
}
var ps = new PlayerStats(_psr.ID, txtLastName.Text, txtFirstName.Text,
(Position) Enum.Parse(typeof (Position), cmbPosition1.SelectedItem.ToString()),
(Position) Enum.Parse(typeof (Position), cmbPosition2.SelectedItem.ToString()),
Convert.ToInt32(txtYearOfBirth.Text), Convert.ToInt32(txtYearsPro.Text), teamF, _psr.TeamS,
chkIsActive.IsChecked.GetValueOrDefault(), false, _psr.Injury,
chkIsAllStar.IsChecked.GetValueOrDefault(), chkIsNBAChampion.IsChecked.GetValueOrDefault(),
_dtOv.Rows[0]) {Height = _psr.Height, Weight = _psr.Weight};
ps.UpdateCareerHighs(recordsList.Single(r => r.Type == "Career"));
ps.UpdateContract(dgvContract.ItemsSource.Cast<PlayerStatsRow>().First());
return ps;
}
/// <summary>
/// Updates the tab viewing the year-by-year overview of the player's stats.
/// </summary>
private void updateYearlyReport()
{
var psrList = new List<PlayerStatsRow>();
var psCareer =
new PlayerStats(new Player(_psr.ID, _psr.TeamF, _psr.LastName, _psr.FirstName, _psr.Position1, _psr.Position2));
string qr = "SELECT * FROM PastPlayerStats WHERE PlayerID = " + _psr.ID + " ORDER BY CAST(\"SOrder\" AS INTEGER)";
DataTable dt = _db.GetDataTable(qr);
foreach (DataRow dr in dt.Rows)
{
var ps = new PlayerStats();
bool isPlayoff = ParseCell.GetBoolean(dr, "isPlayoff");
ps.GetStatsFromDataRow(dr, isPlayoff);
Dictionary<string, double> tempMetrics = isPlayoff ? ps.PlMetrics : ps.Metrics;
PlayerStats.CalculateRates(isPlayoff ? ps.PlTotals : ps.Totals, ref tempMetrics);
string type = isPlayoff
? "Playoffs " + ParseCell.GetString(dr, "SeasonName")
: "Season " + ParseCell.GetString(dr, "SeasonName");
var curPSR = new PlayerStatsRow(ps, type, isPlayoff)
{
TeamFDisplay = ParseCell.GetString(dr, "TeamFin"),
TeamSDisplay = ParseCell.GetString(dr, "TeamSta")
};
psrList.Add(curPSR);
psCareer.AddPlayerStats(ps);
}
for (int i = 1; i <= _maxSeason; i++)
{
var displayNames = new Dictionary<int, string>();
SQLiteIO.GetSeasonDisplayNames(MainWindow.CurrentDB, i, ref displayNames);
string pT = "Players";
if (i != _maxSeason)
{
pT += "S" + i;
}
string q = "select * from " + pT + " where ID = " + _selectedPlayerID;
DataTable res = _db.GetDataTable(q);
if (res.Rows.Count == 1)
{
var ps = new PlayerStats(res.Rows[0], MainWindow.TST);
PlayerStats.CalculateRates(ps.Totals, ref ps.Metrics);
var psr2 = new PlayerStatsRow(ps, "Season " + MainWindow.GetSeasonName(i));
psr2.TeamFDisplay = Misc.GetDisplayName(displayNames, psr2.TeamF);
psr2.TeamSDisplay = Misc.GetDisplayName(displayNames, psr2.TeamS);
psrList.Add(psr2);
psCareer.AddPlayerStats(ps);
}
pT = "PlayoffPlayers";
if (i != _maxSeason)
{
pT += "S" + i;
}
q = "select * from " + pT + " where ID = " + _selectedPlayerID;
res = _db.GetDataTable(q);
if (res.Rows.Count == 1)
{
var ps = new PlayerStats(res.Rows[0], MainWindow.TST, true);
if (ps.PlTotals[PAbbr.GP] > 0)
{
PlayerStats.CalculateRates(ps.PlTotals, ref ps.PlMetrics);
var psr2 = new PlayerStatsRow(ps, "Playoffs " + MainWindow.GetSeasonName(i), true);
psr2.TeamFDisplay = Misc.GetDisplayName(displayNames, psr2.TeamF);
psr2.TeamSDisplay = Misc.GetDisplayName(displayNames, psr2.TeamS);
psrList.Add(psr2);
psCareer.AddPlayerStats(ps, true);
}
}
}
PlayerStats.CalculateRates(psCareer.Totals, ref psCareer.Metrics);
psrList.Add(new PlayerStatsRow(psCareer, "Career", "Career"));
var psrListCollection = new ListCollectionView(psrList);
Debug.Assert(psrListCollection.GroupDescriptions != null, "psrListCollection.GroupDescriptions != null");
psrListCollection.GroupDescriptions.Add(new PropertyGroupDescription("Group"));
dgvYearly.ItemsSource = psrListCollection;
}
/// <summary>
/// Gets a player stats dictionary of only the active players, and calculates their rankingsPerGame.
/// </summary>
private void getActivePlayers()
{
_playersActive = new Dictionary<int, PlayerStats>();
string q = "select * from " + _playersT + " where isActive LIKE \"True\"";
q += " AND isHidden LIKE \"False\"";
DataTable res = _db.GetDataTable(q);
foreach (DataRow r in res.Rows)
{
string q2 = "select * from " + _plPlayersT + " where ID = " + ParseCell.GetInt32(r, "ID");
DataTable plRes = _db.GetDataTable(q2);
var ps = new PlayerStats(r, MainWindow.TST);
_playersActive.Add(ps.ID, ps);
_playersActive[ps.ID].UpdatePlayoffStats(plRes.Rows[0]);
}
_rankingsActive = new PlayerRankings(_playersActive);
_plRankingsActive = new PlayerRankings(_playersActive, true);
}
private static void importPlayerCareerHighs(PlayerStats ps, Dictionary<string, string> redPlayer)
{
ps.CareerHighs[PAbbrT.PTS] = Convert.ToUInt16(redPlayer["GH_CarPts"]);
ps.CareerHighs[PAbbrT.FGM] = Convert.ToUInt16(redPlayer["GH_CarFGM"]);
ps.CareerHighs[PAbbrT.FGA] = Convert.ToUInt16(redPlayer["GH_CarFGA"]);
ps.CareerHighs[PAbbrT.TPM] = Convert.ToUInt16(redPlayer["GH_Car3PM"]);
ps.CareerHighs[PAbbrT.TPA] = Convert.ToUInt16(redPlayer["GH_Car3PA"]);
ps.CareerHighs[PAbbrT.FTM] = Convert.ToUInt16(redPlayer["GH_CarFTM"]);
ps.CareerHighs[PAbbrT.FTA] = Convert.ToUInt16(redPlayer["GH_CarFTA"]);
ps.CareerHighs[PAbbrT.OREB] = Convert.ToUInt16(redPlayer["GH_CarOReb"]);
ps.CareerHighs[PAbbrT.DREB] = Convert.ToUInt16(redPlayer["GH_CarDReb"]);
ps.CareerHighs[PAbbrT.REB] = Convert.ToUInt16(redPlayer["GH_CarRebs"]);
ps.CareerHighs[PAbbrT.AST] = Convert.ToUInt16(redPlayer["GH_CarAst"]);
ps.CareerHighs[PAbbrT.STL] = Convert.ToUInt16(redPlayer["GH_CarStl"]);
ps.CareerHighs[PAbbrT.BLK] = Convert.ToUInt16(redPlayer["GH_CarBlk"]);
}
private void btnOK_Click(object sender, RoutedEventArgs e)
{
var newpst = new Dictionary<int, PlayerStats>(_pst);
if (Equals(tbcAdd.SelectedItem, tabTeams))
{
var lines = Tools.SplitLinesToList(txtTeams.Text, false);
MainWindow.AddInfo = "";
foreach (var line in lines)
{
MainWindow.AddInfo += line + "\n";
}
}
else if (Equals(tbcAdd.SelectedItem, tabPlayers))
{
var i = SQLiteIO.GetMaxPlayerID(MainWindow.CurrentDB);
foreach (var p in players)
{
if (String.IsNullOrWhiteSpace(p.LastName))
{
MessageBox.Show(
"You have to enter the Last Name for all players.", App.AppName, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
p.ID = ++i;
PlayerStats ps;
try
{
ps = new PlayerStats(p, true);
}
catch (FormatException ex)
{
MessageBox.Show(ex.Message, App.AppName, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
newpst.Add(p.ID, ps);
}
MainWindow.PST = newpst;
MainWindow.AddInfo = "$$NST Players Added";
}
Close();
}
/// <summary>Used to filter the PlayerStatsRow results based on any user-specified metric stats criteria.</summary>
/// <param name="o">The o.</param>
/// <returns></returns>
private bool filter(object o)
{
var psr = (PlayerStatsRow) o;
var ps = new PlayerStats(psr);
var keep = true;
var context = new ExpressionContext();
IGenericExpression<bool> ige;
if (!String.IsNullOrWhiteSpace(_yearsProVal))
{
ige = context.CompileGeneric<bool>(psr.YearsPro.ToString() + _yearsProOp + _yearsProVal);
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(_yobVal))
{
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.YearOfBirth.ToString() + _yobOp + _yobVal);
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(_heightVal))
{
var metricHeight = MainWindow.IsImperial
? PlayerStatsRow.ConvertImperialHeightToMetric(_heightVal)
: Convert.ToDouble(_heightVal);
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.Height.ToString() + _heightOp + metricHeight.ToString());
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(_weightVal))
{
var imperialWeight = MainWindow.IsImperial
? Convert.ToDouble(_weightVal)
: PlayerStatsRow.ConvertMetricWeightToImperial(_weightVal);
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.Weight.ToString() + _weightOp + imperialWeight.ToString());
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(_contractYearsLeftVal))
{
context = new ExpressionContext();
ige =
context.CompileGeneric<bool>(
(chkExcludeOption.IsChecked.GetValueOrDefault()
? psr.ContractYearsMinusOption.ToString()
: psr.ContractYears.ToString()) + _contractYearsLeftOp + _contractYearsLeftVal);
if (ige.Evaluate() == false)
{
return false;
}
}
foreach (var contractYear in _contractYears)
{
var parts = contractYear.Split(' ');
ige =
context.CompileGeneric<bool>(
psr.GetType().GetProperty("ContractY" + parts[1]).GetValue(psr, null) + parts[2] + parts[3]);
keep = ige.Evaluate();
if (!keep)
{
return false;
}
}
var stopped = false;
Parallel.ForEach(
_totalsFilters,
(item, loopState) =>
{
var parts = item.Split(' ');
parts[0] = parts[0].Replace("3P", "TP");
parts[0] = parts[0].Replace("TO", "TOS");
context = new ExpressionContext();
ige =
context.CompileGeneric<bool>(psr.GetType().GetProperty(parts[0]).GetValue(psr, null) + parts[1] + parts[2]);
keep = ige.Evaluate();
if (!keep)
{
stopped = true;
loopState.Stop();
}
});
if (!keep || stopped)
{
return false;
}
Parallel.ForEach(
_pgFilters,
(item, loopState) =>
{
var parts = item.Split(' ');
parts[0] = parts[0].Replace("3P", "TP");
parts[0] = parts[0].Replace("%", "p");
context = new ExpressionContext();
var value = psr.GetType().GetProperty(parts[0]).GetValue(psr, null);
if (!Double.IsNaN(Convert.ToDouble(value)))
{
ige = context.CompileGeneric<bool>(value + parts[1] + parts[2]);
keep = ige.Evaluate();
}
else
{
keep = false;
}
if (!keep)
{
stopped = true;
loopState.Stop();
}
});
if (!keep || stopped)
{
return false;
}
Parallel.ForEach(
_metricFilters,
(item, loopState) =>
{
var parts = item.Split(' ');
//parts[0] = parts[0].Replace("%", "p");
//double val = Convert.ToDouble(parts[2]);
context = new ExpressionContext();
var actualValue = ps.Metrics[parts[0]];
var filterType = parts[1];
if (!double.IsNaN(actualValue))
{
if (double.IsPositiveInfinity(actualValue))
{
switch (filterType)
{
case ">":
case ">=":
keep = true;
break;
default:
keep = false;
break;
}
}
else if (double.IsNegativeInfinity(actualValue))
{
switch (filterType)
{
case "<":
case "<=":
keep = true;
break;
default:
keep = false;
break;
}
}
else
{
ige = context.CompileGeneric<bool>(actualValue + filterType + parts[2]);
keep = ige.Evaluate();
}
}
else
{
keep = false;
}
if (!keep)
{
stopped = true;
loopState.Stop();
}
});
if (!keep || stopped)
{
return false;
}
var expCount = _customExpressions.Count;
Parallel.For(
0,
expCount,
(i, loopState) =>
{
var index = i;
var exp = _customExpressions[index];
var itemSParts = exp.Split(new[] { ": " }, StringSplitOptions.None);
var filterParts = itemSParts[2].Split(new[] { ' ' }, 2);
var filterType = filterParts[0];
var filterVal = filterParts.Length == 2 ? filterParts[1] : "";
if (filterType == "All")
{
return;
}
var actualValue = psr.Custom[index];
if (!double.IsNaN(actualValue))
{
if (double.IsPositiveInfinity(actualValue))
{
switch (filterType)
{
case ">":
case ">=":
keep = true;
break;
default:
keep = false;
break;
}
}
else if (double.IsNegativeInfinity(actualValue))
{
switch (filterType)
{
case "<":
case "<=":
keep = true;
break;
default:
keep = false;
break;
}
}
else
{
ige = new ExpressionContext().CompileGeneric<bool>(actualValue + filterType + filterVal);
keep = ige.Evaluate();
}
}
else
{
keep = false;
}
if (!keep)
{
stopped = true;
loopState.Stop();
}
});
if (!keep || stopped)
{
return false;
}
return keep;
}
/// <summary>
/// Used to filter the PlayerStatsRow results based on any user-specified metric stats criteria.
/// </summary>
/// <param name="o">The o.</param>
/// <returns></returns>
private bool filter(object o)
{
var psr = (PlayerStatsRow) o;
var ps = new PlayerStats(psr);
bool keep = true;
var context = new ExpressionContext();
IGenericExpression<bool> ige;
if (!String.IsNullOrWhiteSpace(txtYearsProVal.Text))
{
ige = context.CompileGeneric<bool>(psr.YearsPro.ToString() + cmbYearsProOp.SelectedItem + txtYearsProVal.Text);
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(txtYOBVal.Text))
{
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.YearOfBirth.ToString() + cmbYOBOp.SelectedItem + txtYOBVal.Text);
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(txtHeightVal.Text))
{
double metricHeight = MainWindow.IsImperial
? PlayerStatsRow.ConvertImperialHeightToMetric(txtHeightVal.Text)
: Convert.ToDouble(txtHeightVal.Text);
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.Height.ToString() + cmbHeightOp.SelectedItem + metricHeight.ToString());
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(txtWeightVal.Text))
{
double imperialWeight = MainWindow.IsImperial
? Convert.ToDouble(txtWeightVal.Text)
: PlayerStatsRow.ConvertMetricWeightToImperial(txtWeightVal.Text);
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.Weight.ToString() + cmbWeightOp.SelectedItem + imperialWeight.ToString());
if (ige.Evaluate() == false)
{
return false;
}
}
if (!String.IsNullOrWhiteSpace(txtContractYLeftVal.Text))
{
context = new ExpressionContext();
ige =
context.CompileGeneric<bool>((chkExcludeOption.IsChecked.GetValueOrDefault()
? psr.ContractYearsMinusOption.ToString()
: psr.ContractYears.ToString()) + cmbContractYLeftOp.SelectedItem +
txtContractYLeftVal.Text);
if (ige.Evaluate() == false)
{
return false;
}
}
foreach (string contractYear in lstContract.Items.Cast<string>())
{
string[] parts = contractYear.Split(' ');
ige =
context.CompileGeneric<bool>(psr.GetType().GetProperty("ContractY" + parts[1]).GetValue(psr, null) + parts[2] +
parts[3]);
keep = ige.Evaluate();
if (!keep)
{
return keep;
}
}
IEnumerable<string> totalsFilters = lstTotals.Items.Cast<string>();
Parallel.ForEach(totalsFilters, (item, loopState) =>
{
string[] parts = item.Split(' ');
parts[0] = parts[0].Replace("3P", "TP");
parts[0] = parts[0].Replace("TO", "TOS");
context = new ExpressionContext();
ige = context.CompileGeneric<bool>(psr.GetType().GetProperty(parts[0]).GetValue(psr, null) + parts[1] + parts[2]);
keep = ige.Evaluate();
if (!keep)
{
loopState.Stop();
}
});
if (!keep)
{
return keep;
}
IEnumerable<string> pgFilters = lstAvg.Items.Cast<string>();
Parallel.ForEach(pgFilters, (item, loopState) =>
{
string[] parts = item.Split(' ');
parts[0] = parts[0].Replace("3P", "TP");
parts[0] = parts[0].Replace("%", "p");
context = new ExpressionContext();
object value = psr.GetType().GetProperty(parts[0]).GetValue(psr, null);
if (!Double.IsNaN(Convert.ToDouble(value)))
{
ige = context.CompileGeneric<bool>(value + parts[1] + parts[2]);
keep = ige.Evaluate();
}
else
{
keep = false;
}
if (!keep)
{
loopState.Stop();
}
});
if (!keep)
{
return keep;
}
IEnumerable<string> metricFilters = lstMetrics.Items.Cast<string>();
Parallel.ForEach(metricFilters, (item, loopState) =>
{
string[] parts = item.Split(' ');
parts[0] = parts[0].Replace("%", "p");
//double val = Convert.ToDouble(parts[2]);
context = new ExpressionContext();
double actualValue = ps.Metrics[parts[0]];
string filterType = parts[1];
if (!double.IsNaN(actualValue))
{
if (double.IsPositiveInfinity(actualValue))
{
switch (filterType)
{
case ">":
case ">=":
keep = true;
break;
default:
keep = false;
break;
}
}
else if (double.IsNegativeInfinity(actualValue))
{
switch (filterType)
{
case "<":
case "<=":
keep = true;
break;
default:
keep = false;
break;
}
}
else
{
ige = context.CompileGeneric<bool>(actualValue + filterType + parts[2]);
keep = ige.Evaluate();
}
}
else
{
keep = false;
}
if (!keep)
{
loopState.Stop();
}
});
if (!keep)
{
return keep;
}
int expCount = _customExpressions.Count;
Parallel.For(0, expCount, (i, loopState) =>
{
int index = i;
string exp = _customExpressions[index];
string[] itemSParts = exp.Split(new[] {": "}, StringSplitOptions.None);
string[] filterParts = itemSParts[2].Split(new[] {' '}, 2);
string filterType = filterParts[0];
string filterVal = filterParts.Length == 2 ? filterParts[1] : "";
if (filterType == "All")
{
return;
}
double actualValue = psr.Custom[index];
if (!double.IsNaN(actualValue))
{
if (double.IsPositiveInfinity(actualValue))
{
switch (filterType)
{
case ">":
case ">=":
keep = true;
break;
default:
keep = false;
break;
}
}
else if (double.IsNegativeInfinity(actualValue))
{
switch (filterType)
{
case "<":
case "<=":
keep = true;
break;
default:
keep = false;
break;
}
}
else
{
ige = new ExpressionContext().CompileGeneric<bool>(actualValue + filterType + filterVal);
keep = ige.Evaluate();
}
}
else
{
keep = false;
}
if (!keep)
{
loopState.Stop();
}
});
return keep;
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerRankings" /> class, and calculates the rankingsPerGame.
/// </summary>
/// <param name="pst">The PlayerStats dictionary, containing all player information.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the rankingsPerGame will take only playoff performances into account.
/// </param>
public PlayerRankings(Dictionary<int, PlayerStats> pst, bool playoffs = false)
{
Dictionary<int, PlayerStats> validPlayers = pst.Where(ps => ps.Value.Totals[PAbbr.GP] > 0)
.ToDictionary(a => a.Key, a => a.Value);
var dummyPS = new PlayerStats();
//int firstPlayerID = validPlayers.Keys.ToList()[0];
int totalsCount = dummyPS.Totals.Length;
int metricsCount = dummyPS.Metrics.Count;
foreach (var kvp in validPlayers)
{
RankingsPerGame.Add(kvp.Key, new int[PerGameCount]);
RankingsTotal.Add(kvp.Key, new int[totalsCount]);
RankingsMetrics.Add(kvp.Key, new Dictionary<string, int>());
}
foreach (string metricName in PAbbr.MetricsNames)
{
RevRankingsMetrics.Add(metricName, new Dictionary<int, int>());
}
for (int i = 0; i < PerGameCount; i++)
{
RevRankingsPerGame.Add(i, new Dictionary<int, int>());
}
for (int i = 0; i < totalsCount; i++)
{
RevRankingsTotals.Add(i, new Dictionary<int, int>());
}
for (int j = 0; j < PerGameCount; j++)
{
Dictionary<int, float> perGame = !playoffs
? validPlayers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.PerGame[j])
: validPlayers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.PlPerGame[j]);
var tempList = new List<KeyValuePair<int, float>>(perGame);
tempList.Sort((x, y) => x.Value.CompareTo(y.Value));
if (j != PAbbr.FPG && j != PAbbr.TPG)
{
tempList.Reverse();
}
int k = 1;
foreach (var kvp in tempList)
{
RankingsPerGame[kvp.Key][j] = k;
RevRankingsPerGame[j].Add(k, kvp.Key);
k++;
}
}
int plCount = pst.Count;
foreach (var kvp in pst.Where(ps => ps.Value.Totals[PAbbr.GP] == 0))
{
RankingsPerGame.Add(kvp.Key, new int[PerGameCount]);
for (int i = 0; i < PerGameCount; i++)
{
RankingsPerGame[kvp.Key][i] = plCount;
}
}
for (int j = 0; j < totalsCount; j++)
{
Dictionary<int, uint> totals = !playoffs
? validPlayers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Totals[j])
: validPlayers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.PlTotals[j]);
var tempList = new List<KeyValuePair<int, uint>>(totals);
tempList.Sort((x, y) => x.Value.CompareTo(y.Value));
if (j != PAbbr.FOUL && j != PAbbr.TOS)
{
tempList.Reverse();
}
int k = 1;
foreach (var kvp in tempList)
{
RankingsTotal[kvp.Key][j] = k;
RevRankingsTotals[j].Add(k, kvp.Key);
k++;
}
}
foreach (var kvp in pst.Where(ps => ps.Value.Totals[PAbbr.GP] == 0))
{
RankingsTotal.Add(kvp.Key, new int[totalsCount]);
for (int i = 0; i < totalsCount; i++)
{
RankingsTotal[kvp.Key][i] = plCount;
}
}
var badMetrics = new List<string> {"TO%", "TOR"};
List<string> metricsNames = PAbbr.MetricsNames;
for (int j = 0; j < metricsCount; j++)
{
Dictionary<int, double> metrics = !playoffs
? validPlayers.ToDictionary(kvp => kvp.Key,
kvp => kvp.Value.Metrics[metricsNames[j]])
: validPlayers.ToDictionary(kvp => kvp.Key,
kvp => kvp.Value.PlMetrics[metricsNames[j]]);
var tempList = new List<KeyValuePair<int, double>>(metrics);
tempList.Sort((x, y) => x.Value.CompareTo(y.Value));
if (!badMetrics.Contains(metricsNames[j]))
{
tempList.Reverse();
}
int k = 1;
foreach (var kvp in tempList)
{
RankingsMetrics[kvp.Key][metricsNames[j]] = k;
RevRankingsMetrics[metricsNames[j]].Add(k, kvp.Key);
k++;
}
}
foreach (var kvp in pst.Where(ps => ps.Value.Totals[PAbbr.GP] == 0))
{
RankingsMetrics.Add(kvp.Key, new Dictionary<string, int>());
for (int i = 0; i < metricsCount; i++)
{
RankingsMetrics[kvp.Key][metricsNames[i]] = plCount;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerStatsRow" /> class.
/// </summary>
/// <param name="ps">The PlayerStats instance.</param>
/// <param name="type">The type.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the interface provided will show playoff stats.
/// </param>
public PlayerStatsRow(PlayerStats ps, string type, bool playoffs = false)
: this(ps, playoffs)
{
Type = type;
}
/// <summary>Calculates the league PerGame.</summary>
/// <param name="playerStats">The player stats.</param>
/// <param name="teamStats">The team stats.</param>
/// <returns></returns>
public static PlayerStats CalculateLeagueAverages(
Dictionary<int, PlayerStats> playerStats, Dictionary<int, TeamStats> teamStats)
{
var lps = new PlayerStats(new Player(-1, -1, "League", "Averages", Position.None, Position.None));
foreach (var key in playerStats.Keys)
{
lps.AddPlayerStats(playerStats[key]);
}
var ls = new TeamStats(-2, "League");
for (var i = 0; i < teamStats.Count; i++)
{
ls.AddTeamStats(teamStats[i], Span.Season);
ls.AddTeamStats(teamStats[i], Span.Playoffs);
}
ls.CalcMetrics(ls);
ls.CalcMetrics(ls, true);
foreach (var name in PlayerStatsHelper.MetricsNames)
{
try
{
lps.Metrics[name] =
playerStats.Where(ps => !Double.IsNaN(ps.Value.Metrics[name]) && !Double.IsInfinity(ps.Value.Metrics[name]))
.Average(ps => ps.Value.Metrics[name]);
}
catch (InvalidOperationException)
{
lps.Metrics[name] = Double.NaN;
}
try
{
lps.PlMetrics[name] =
playerStats.Where(ps => !Double.IsNaN(ps.Value.PlMetrics[name]) && !Double.IsInfinity(ps.Value.Metrics[name]))
.Average(ps => ps.Value.PlMetrics[name]);
}
catch (InvalidOperationException)
{
lps.Metrics[name] = Double.NaN;
}
}
var playerCount = (uint) playerStats.Count;
for (var i = 0; i < lps.Totals.Length; i++)
{
lps.Totals[i] /= playerCount;
lps.PlTotals[i] /= playerCount;
}
//ps.CalcAvg();
return lps;
}
/// <summary>
/// Initializes a new instance of the <see cref="PlayerStatsRow" /> class.
/// </summary>
/// <param name="ps">The PlayerStats instance.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the interface provided will show playoff stats.
/// </param>
public PlayerStatsRow(PlayerStats ps, bool playoffs = false, bool calcRatings = true, string teamName = null)
: this()
{
LastName = ps.LastName;
FirstName = ps.FirstName;
ID = ps.ID;
Position1 = ps.Position1;
Position2 = ps.Position2;
TeamF = ps.TeamF;
TeamFDisplay = teamName ?? MainWindow.DisplayNames[TeamF];
TeamS = ps.TeamS;
if (TeamS == -1)
{
TeamSDisplay = "";
}
else
{
try
{
TeamSDisplay = MainWindow.DisplayNames[TeamS];
}
catch (KeyNotFoundException)
{
TeamSDisplay = "Unknown";
}
}
IsActive = ps.IsActive;
IsHidden = ps.IsHidden;
IsAllStar = ps.IsAllStar;
Injury = ps.Injury.DeepClone(null);
IsNBAChampion = ps.IsNBAChampion;
YearOfBirth = ps.YearOfBirth;
YearsPro = ps.YearsPro;
ContractOption = ps.Contract.Option;
for (int i = 1; i <= 7; i++)
{
typeof (PlayerStatsRow).GetProperty("ContractY" + i).SetValue(this, ps.Contract.TryGetSalary(i), null);
}
ContractYears = ps.Contract.GetYears();
ContractYearsMinusOption = ps.Contract.GetYearsMinusOption();
Custom = new List<double>();
Height = ps.Height;
Weight = ps.Weight;
if (!playoffs)
{
GP = ps.Totals[PAbbr.GP];
GS = ps.Totals[PAbbr.GS];
MINS = ps.Totals[PAbbr.MINS];
PTS = ps.Totals[PAbbr.PTS];
FGM = ps.Totals[PAbbr.FGM];
FGMPG = ((float) FGM/GP);
FGA = ps.Totals[PAbbr.FGA];
FGAPG = ((float) FGA/GP);
TPM = ps.Totals[PAbbr.TPM];
TPMPG = ((float) TPM/GP);
TPA = ps.Totals[PAbbr.TPA];
TPAPG = ((float) TPA/GP);
FTM = ps.Totals[PAbbr.FTM];
FTMPG = ((float) FTM/GP);
FTA = ps.Totals[PAbbr.FTA];
FTAPG = ((float) FTA/GP);
OREB = ps.Totals[PAbbr.OREB];
DREB = ps.Totals[PAbbr.DREB];
REB = (UInt16) (OREB + DREB);
STL = ps.Totals[PAbbr.STL];
TOS = ps.Totals[PAbbr.TOS];
BLK = ps.Totals[PAbbr.BLK];
AST = ps.Totals[PAbbr.AST];
FOUL = ps.Totals[PAbbr.FOUL];
MPG = ps.PerGame[PAbbr.MPG];
PPG = ps.PerGame[PAbbr.PPG];
FGp = ps.PerGame[PAbbr.FGp];
FGeff = ps.PerGame[PAbbr.FGeff];
TPp = ps.PerGame[PAbbr.TPp];
TPeff = ps.PerGame[PAbbr.TPeff];
FTp = ps.PerGame[PAbbr.FTp];
FTeff = ps.PerGame[PAbbr.FTeff];
RPG = ps.PerGame[PAbbr.RPG];
ORPG = ps.PerGame[PAbbr.ORPG];
DRPG = ps.PerGame[PAbbr.DRPG];
SPG = ps.PerGame[PAbbr.SPG];
TPG = ps.PerGame[PAbbr.TPG];
BPG = ps.PerGame[PAbbr.BPG];
APG = ps.PerGame[PAbbr.APG];
FPG = ps.PerGame[PAbbr.FPG];
try
{
PTSR = ps.Metrics["PTSR"];
REBR = ps.Metrics["REBR"];
OREBR = ps.Metrics["OREBR"];
ASTR = ps.Metrics["ASTR"];
BLKR = ps.Metrics["BLKR"];
STLR = ps.Metrics["STLR"];
TOR = ps.Metrics["TOR"];
FTR = ps.Metrics["FTR"];
FTAR = ps.Metrics["FTAR"];
GmSc = ps.Metrics["GmSc"];
GmScE = ps.Metrics["GmScE"];
EFF = ps.Metrics["EFF"];
EFGp = ps.Metrics["EFG%"];
TSp = ps.Metrics["TS%"];
ASTp = ps.Metrics["AST%"];
STLp = ps.Metrics["STL%"];
TOp = ps.Metrics["TO%"];
USGp = ps.Metrics["USG%"];
try
{
PER = ps.Metrics["PER"];
}
catch (Exception)
{
PER = Double.NaN;
}
BLKp = ps.Metrics["BLK%"];
DREBp = ps.Metrics["DREB%"];
OREBp = ps.Metrics["OREB%"];
REBp = ps.Metrics["REB%"];
PPR = ps.Metrics["PPR"];
}
catch (KeyNotFoundException)
{
}
}
else
{
GP = ps.PlTotals[PAbbr.GP];
GS = ps.PlTotals[PAbbr.GS];
MINS = ps.PlTotals[PAbbr.MINS];
PTS = ps.PlTotals[PAbbr.PTS];
FGM = ps.PlTotals[PAbbr.FGM];
FGMPG = ((float) FGM/GP);
FGA = ps.PlTotals[PAbbr.FGA];
FGAPG = ((float) FGA/GP);
TPM = ps.PlTotals[PAbbr.TPM];
TPMPG = ((float) TPM/GP);
TPA = ps.PlTotals[PAbbr.TPA];
TPAPG = (uint) ((double) TPA/GP);
FTM = ps.PlTotals[PAbbr.FTM];
FTMPG = ((float) FTM/GP);
FTA = ps.PlTotals[PAbbr.FTA];
FTAPG = ((float) FTA/GP);
OREB = ps.PlTotals[PAbbr.OREB];
DREB = ps.PlTotals[PAbbr.DREB];
REB = (UInt16) (OREB + DREB);
STL = ps.PlTotals[PAbbr.STL];
TOS = ps.PlTotals[PAbbr.TOS];
BLK = ps.PlTotals[PAbbr.BLK];
AST = ps.PlTotals[PAbbr.AST];
FOUL = ps.PlTotals[PAbbr.FOUL];
MPG = ps.PlPerGame[PAbbr.MPG];
PPG = ps.PlPerGame[PAbbr.PPG];
FGp = ps.PlPerGame[PAbbr.FGp];
FGeff = ps.PlPerGame[PAbbr.FGeff];
TPp = ps.PlPerGame[PAbbr.TPp];
TPeff = ps.PlPerGame[PAbbr.TPeff];
FTp = ps.PlPerGame[PAbbr.FTp];
FTeff = ps.PlPerGame[PAbbr.FTeff];
RPG = ps.PlPerGame[PAbbr.RPG];
ORPG = ps.PlPerGame[PAbbr.ORPG];
DRPG = ps.PlPerGame[PAbbr.DRPG];
SPG = ps.PlPerGame[PAbbr.SPG];
TPG = ps.PlPerGame[PAbbr.TPG];
BPG = ps.PlPerGame[PAbbr.BPG];
APG = ps.PlPerGame[PAbbr.APG];
FPG = ps.PlPerGame[PAbbr.FPG];
try
{
PTSR = ps.PlMetrics["PTSR"];
REBR = ps.PlMetrics["REBR"];
OREBR = ps.PlMetrics["OREBR"];
ASTR = ps.PlMetrics["ASTR"];
BLKR = ps.PlMetrics["BLKR"];
STLR = ps.PlMetrics["STLR"];
TOR = ps.PlMetrics["TOR"];
FTR = ps.PlMetrics["FTR"];
FTAR = ps.PlMetrics["FTAR"];
GmSc = ps.PlMetrics["GmSc"];
GmScE = ps.PlMetrics["GmScE"];
EFF = ps.PlMetrics["EFF"];
EFGp = ps.PlMetrics["EFG%"];
TSp = ps.PlMetrics["TS%"];
ASTp = ps.PlMetrics["AST%"];
STLp = ps.PlMetrics["STL%"];
TOp = ps.PlMetrics["TO%"];
USGp = ps.PlMetrics["USG%"];
try
{
PER = ps.PlMetrics["PER"];
}
catch (Exception)
{
PER = Double.NaN;
}
BLKp = ps.PlMetrics["BLK%"];
DREBp = ps.PlMetrics["DREB%"];
OREBp = ps.PlMetrics["OREB%"];
REBp = ps.PlMetrics["REB%"];
PPR = ps.PlMetrics["PPR"];
}
catch (KeyNotFoundException)
{
}
}
if (calcRatings)
{
calculate2KRatings(playoffs);
}
}
/// <summary>
/// Updates the box score data grid.
/// </summary>
/// <param name="teamID">Name of the team.</param>
/// <param name="playersList">The players list.</param>
/// <param name="pbsList">The player box score list.</param>
/// <param name="playersT">The players' SQLite table name.</param>
/// <param name="loading">
/// if set to <c>true</c>, it is assumed that a pre-existing box score is being loaded.
/// </param>
private static void updateBoxScoreDataGrid(int teamID, out ObservableCollection<KeyValuePair<int, string>> playersList,
ref SortableBindingList<PlayerBoxScore> pbsList, string playersT, bool loading)
{
var db = new SQLiteDatabase(MainWindow.CurrentDB);
string q = "select * from " + playersT + " where TeamFin = " + teamID + "";
q += " ORDER BY LastName ASC";
DataTable res = db.GetDataTable(q);
playersList = new ObservableCollection<KeyValuePair<int, string>>();
if (!loading)
{
pbsList = new SortableBindingList<PlayerBoxScore>();
}
foreach (DataRow r in res.Rows)
{
var ps = new PlayerStats(r, MainWindow.TST);
playersList.Add(new KeyValuePair<int, string>(ps.ID, ps.LastName + ", " + ps.FirstName));
if (!loading)
{
var pbs = new PlayerBoxScore {PlayerID = ps.ID, TeamID = teamID};
pbsList.Add(pbs);
}
}
for (int i = 0; i < pbsList.Count; i++)
{
PlayerBoxScore cur = pbsList[i];
string name = MainWindow.PST[cur.PlayerID].LastName + ", " + MainWindow.PST[cur.PlayerID].FirstName;
var player = new KeyValuePair<int, string>(cur.PlayerID, name);
cur.Name = name;
if (!playersList.Contains(player))
{
playersList.Add(player);
}
pbsList[i] = cur;
}
playersList = new ObservableCollection<KeyValuePair<int, string>>(playersList.OrderBy(item => item.Value));
}
