private void highlightAndAddPlayers(KeyValuePair<int, PlayerStats> pair, ref ObservableCollection<PlayerStatsRow> psrObservable)
{
var psr = new PlayerStatsRow(pair.Value);
if (_playersToHighlight.Contains(psr.ID))
{
psr.Highlight = true;
}
psrObservable.Add(psr);
}
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="PlayerStats" /> class.
/// </summary>
/// <param name="playerStatsRow">The player stats row.</param>
/// <param name="playoffs">
/// if set to <c>true</c> the row is assumed to contain playoff stats.
/// </param>
public PlayerStats(PlayerStatsRow playerStatsRow, bool playoffs = false)
: this()
{
LastName = playerStatsRow.LastName;
FirstName = playerStatsRow.FirstName;
if (!playoffs)
{
Totals[PAbbrT.GP] = playerStatsRow.GP;
Totals[PAbbrT.GS] = playerStatsRow.GS;
Totals[PAbbrT.MINS] = playerStatsRow.MINS;
Totals[PAbbrT.PTS] = playerStatsRow.PTS;
Totals[PAbbrT.FGM] = playerStatsRow.FGM;
Totals[PAbbrT.FGA] = playerStatsRow.FGA;
Totals[PAbbrT.TPM] = playerStatsRow.TPM;
Totals[PAbbrT.TPA] = playerStatsRow.TPA;
Totals[PAbbrT.FTM] = playerStatsRow.FTM;
Totals[PAbbrT.FTA] = playerStatsRow.FTA;
Totals[PAbbrT.OREB] = playerStatsRow.OREB;
Totals[PAbbrT.DREB] = playerStatsRow.DREB;
Totals[PAbbrT.STL] = playerStatsRow.STL;
Totals[PAbbrT.TOS] = playerStatsRow.TOS;
Totals[PAbbrT.BLK] = playerStatsRow.BLK;
Totals[PAbbrT.AST] = playerStatsRow.AST;
Totals[PAbbrT.FOUL] = playerStatsRow.FOUL;
Metrics["GmSc"] = playerStatsRow.GmSc;
Metrics["GmScE"] = playerStatsRow.GmScE;
Metrics["EFF"] = playerStatsRow.EFF;
Metrics["EFG%"] = playerStatsRow.EFGp;
Metrics["TS%"] = playerStatsRow.TSp;
Metrics["AST%"] = playerStatsRow.ASTp;
Metrics["STL%"] = playerStatsRow.STLp;
Metrics["TO%"] = playerStatsRow.TOp;
Metrics["USG%"] = playerStatsRow.USGp;
Metrics["PTSR"] = playerStatsRow.PTSR;
Metrics["REBR"] = playerStatsRow.REBR;
Metrics["OREBR"] = playerStatsRow.OREBR;
Metrics["ASTR"] = playerStatsRow.ASTR;
Metrics["BLKR"] = playerStatsRow.BLKR;
Metrics["STLR"] = playerStatsRow.STLR;
Metrics["TOR"] = playerStatsRow.TOR;
Metrics["FTR"] = playerStatsRow.FTR;
Metrics["PER"] = playerStatsRow.PER;
Metrics["BLK%"] = playerStatsRow.BLKp;
Metrics["DREB%"] = playerStatsRow.DREBp;
Metrics["OREB%"] = playerStatsRow.OREBp;
Metrics["REB%"] = playerStatsRow.REBp;
Metrics["PPR"] = playerStatsRow.PPR;
}
else
{
PlTotals[PAbbrT.GP] = playerStatsRow.GP;
PlTotals[PAbbrT.GS] = playerStatsRow.GS;
PlTotals[PAbbrT.MINS] = playerStatsRow.MINS;
PlTotals[PAbbrT.PTS] = playerStatsRow.PTS;
PlTotals[PAbbrT.FGM] = playerStatsRow.FGM;
PlTotals[PAbbrT.FGA] = playerStatsRow.FGA;
PlTotals[PAbbrT.TPM] = playerStatsRow.TPM;
PlTotals[PAbbrT.TPA] = playerStatsRow.TPA;
PlTotals[PAbbrT.FTM] = playerStatsRow.FTM;
PlTotals[PAbbrT.FTA] = playerStatsRow.FTA;
PlTotals[PAbbrT.OREB] = playerStatsRow.OREB;
PlTotals[PAbbrT.DREB] = playerStatsRow.DREB;
PlTotals[PAbbrT.STL] = playerStatsRow.STL;
PlTotals[PAbbrT.TOS] = playerStatsRow.TOS;
PlTotals[PAbbrT.BLK] = playerStatsRow.BLK;
PlTotals[PAbbrT.AST] = playerStatsRow.AST;
PlTotals[PAbbrT.FOUL] = playerStatsRow.FOUL;
PlMetrics["GmSc"] = playerStatsRow.GmSc;
PlMetrics["GmScE"] = playerStatsRow.GmScE;
PlMetrics["EFF"] = playerStatsRow.EFF;
PlMetrics["EFG%"] = playerStatsRow.EFGp;
PlMetrics["TS%"] = playerStatsRow.TSp;
PlMetrics["AST%"] = playerStatsRow.ASTp;
PlMetrics["STL%"] = playerStatsRow.STLp;
PlMetrics["TO%"] = playerStatsRow.TOp;
PlMetrics["USG%"] = playerStatsRow.USGp;
PlMetrics["PTSR"] = playerStatsRow.PTSR;
PlMetrics["REBR"] = playerStatsRow.REBR;
PlMetrics["OREBR"] = playerStatsRow.OREBR;
PlMetrics["ASTR"] = playerStatsRow.ASTR;
PlMetrics["BLKR"] = playerStatsRow.BLKR;
PlMetrics["STLR"] = playerStatsRow.STLR;
PlMetrics["TOR"] = playerStatsRow.TOR;
PlMetrics["FTR"] = playerStatsRow.FTR;
PlMetrics["PER"] = playerStatsRow.PER;
PlMetrics["BLK%"] = playerStatsRow.BLKp;
PlMetrics["DREB%"] = playerStatsRow.DREBp;
PlMetrics["OREB%"] = playerStatsRow.OREBp;
PlMetrics["REB%"] = playerStatsRow.REBp;
PlMetrics["PPR"] = playerStatsRow.PPR;
}
ID = playerStatsRow.ID;
Position1 = playerStatsRow.Position1;
Position2 = playerStatsRow.Position2;
TeamF = playerStatsRow.TeamF;
TeamS = playerStatsRow.TeamS;
YearOfBirth = playerStatsRow.YearOfBirth;
YearsPro = playerStatsRow.YearsPro;
IsSigned = playerStatsRow.IsSigned;
IsHidden = playerStatsRow.IsHidden;
IsAllStar = playerStatsRow.IsAllStar;
Injury = PlayerInjury.InjuryTypes.ContainsValue(playerStatsRow.InjuryName)
? new PlayerInjury(
PlayerInjury.InjuryTypes.Single(pi => pi.Value == playerStatsRow.InjuryName).Key,
playerStatsRow.InjuryDaysLeft)
: new PlayerInjury(playerStatsRow.InjuryName, playerStatsRow.InjuryDaysLeft);
IsNBAChampion = playerStatsRow.IsNBAChampion;
Contract.Option = playerStatsRow.ContractOption;
Contract.ContractSalaryPerYear.Clear();
for (var i = 1; i <= 7; i++)
{
var salary = Convert.ToInt32(typeof(PlayerStatsRow).GetProperty("ContractY" + i).GetValue(playerStatsRow, null));
if (salary == 0)
{
break;
}
Contract.ContractSalaryPerYear.Add(salary);
}
Height = playerStatsRow.Height;
Weight = playerStatsRow.Weight;
CalcAvg();
}
private static int comparePSRs(string property, PlayerStatsRow pmsr1, PlayerStatsRow pmsr2)
{
return
Convert.ToDouble(typeof (PlayerStatsRow).GetProperty(property).GetValue(pmsr1, null))
.CompareTo(Convert.ToDouble(typeof (PlayerStatsRow).GetProperty(property).GetValue(pmsr2, null)));
}
public void UpdateContract(PlayerStatsRow psr)
{
Contract.Option = psr.ContractOption;
Contract.ContractSalaryPerYear.Clear();
for (var i = 1; i <= 7; i++)
{
var salary = Convert.ToInt32(typeof(PlayerStatsRow).GetProperty("ContractY" + i).GetValue(psr, null));
if (salary == 0)
{
break;
}
Contract.ContractSalaryPerYear.Add(salary);
}
}
/// <summary>Updates the playoff stats.</summary>
/// <param name="pl_psr">The Playoffs PlayerStatsRow instance to get the stats from.</param>
public void UpdatePlayoffStats(PlayerStatsRow pl_psr)
{
PlTotals[PAbbrT.GP] = pl_psr.GP;
PlTotals[PAbbrT.GS] = pl_psr.GS;
PlTotals[PAbbrT.MINS] = pl_psr.MINS;
PlTotals[PAbbrT.PTS] = pl_psr.PTS;
PlTotals[PAbbrT.FGM] = pl_psr.FGM;
PlTotals[PAbbrT.FGA] = pl_psr.FGA;
PlTotals[PAbbrT.TPM] = pl_psr.TPM;
PlTotals[PAbbrT.TPA] = pl_psr.TPA;
PlTotals[PAbbrT.FTM] = pl_psr.FTM;
PlTotals[PAbbrT.FTA] = pl_psr.FTA;
PlTotals[PAbbrT.OREB] = pl_psr.OREB;
PlTotals[PAbbrT.DREB] = pl_psr.DREB;
PlTotals[PAbbrT.STL] = pl_psr.STL;
PlTotals[PAbbrT.TOS] = pl_psr.TOS;
PlTotals[PAbbrT.BLK] = pl_psr.BLK;
PlTotals[PAbbrT.AST] = pl_psr.AST;
PlTotals[PAbbrT.FOUL] = pl_psr.FOUL;
CalcAvg(true);
}
/// <summary>
/// Prepares and presents the player stats.
/// </summary>
/// <param name="leaders">
/// if set to <c>true</c>, the stats are calculated based on the NBA rules for League Leaders standings.
/// </param>
private void preparePlayerStats()
{
_psrList = new List<PlayerStatsRow>();
_lPSR = new List<PlayerStatsRow>();
_plPSRList = new List<PlayerStatsRow>();
_plLpsr = new List<PlayerStatsRow>();
_leadersList = new List<PlayerStatsRow>();
_plLeadersList = new List<PlayerStatsRow>();
_myLeadersList = new List<PlayerStatsRow>();
_plMyLeadersList = new List<PlayerStatsRow>();
var worker1 = new BackgroundWorker {WorkerReportsProgress = true};
txbStatus.FontWeight = FontWeights.Bold;
txbStatus.Text = "Please wait while player PerGame and metric stats are being calculated...";
int i = 0;
int playerCount = -1;
worker1.DoWork += delegate
{
_sem.WaitOne();
_psrList = new List<PlayerStatsRow>();
_lPSR = new List<PlayerStatsRow>();
_plPSRList = new List<PlayerStatsRow>();
_plLpsr = new List<PlayerStatsRow>();
playerCount = _pst.Count;
foreach (var kvp in _pst)
{
if (kvp.Value.IsHidden)
{
continue;
}
var psr = new PlayerStatsRow(kvp.Value);
var plPSR = new PlayerStatsRow(kvp.Value, true);
if (psr.IsActive)
{
if (!inCurrentFilter(_tst[psr.TeamF]))
{
continue;
}
psr.TeamFDisplay = _tst[psr.TeamF].DisplayName;
plPSR.TeamFDisplay = psr.TeamFDisplay;
}
else
{
if (_filterType != TeamFilter.League)
{
continue;
}
psr.TeamFDisplay = "- Inactive -";
plPSR.TeamFDisplay = psr.TeamFDisplay;
}
_psrList.Add(psr);
_plPSRList.Add(plPSR);
worker1.ReportProgress(1);
}
PlayerStats leagueAverages = PlayerStats.CalculateLeagueAverages(_pst, _tst);
_lPSR.Add(new PlayerStatsRow(leagueAverages));
_plLpsr.Add(new PlayerStatsRow(leagueAverages, true));
_psrList.Sort((psr1, psr2) => psr1.GmSc.CompareTo(psr2.GmSc));
_psrList.Reverse();
_plPSRList.Sort((psr1, psr2) => psr1.GmSc.CompareTo(psr2.GmSc));
_plPSRList.Reverse();
foreach (PlayerStatsRow psr in _psrList)
{
if (psr.IsActive)
{
_leadersList.Add(psr.ConvertToLeagueLeader(_tst));
_myLeadersList.Add(psr.ConvertToMyLeagueLeader(_tst));
}
}
foreach (PlayerStatsRow psr in _plPSRList)
{
if (psr.IsActive)
{
_plLeadersList.Add(psr.ConvertToLeagueLeader(_tst, true));
_plMyLeadersList.Add(psr.ConvertToMyLeagueLeader(_tst, true));
}
}
_leadersList.Sort((psr1, psr2) => psr1.PPG.CompareTo(psr2.PPG));
_leadersList.Reverse();
_plLeadersList.Sort((psr1, psr2) => psr1.PPG.CompareTo(psr2.PPG));
_plLeadersList.Reverse();
_myLeadersList.Sort((psr1, psr2) => psr1.PPG.CompareTo(psr2.PPG));
_myLeadersList.Reverse();
_plMyLeadersList.Sort((psr1, psr2) => psr1.PPG.CompareTo(psr2.PPG));
_plMyLeadersList.Reverse();
};
worker1.ProgressChanged += delegate
{
if (++i < playerCount)
{
txbStatus.Text = "Please wait while player PerGame and metric stats are being calculated (" + i + "/" +
playerCount + " completed)...";
}
else
{
txbStatus.Text = "Please wait as best performers and best starting 5 are being calculated...";
}
};
worker1.RunWorkerCompleted += delegate
{
bool isSeason = rbSeason.IsChecked.GetValueOrDefault();
dgvPlayerStats.ItemsSource = isSeason ? _psrList : _plPSRList;
dgvLeaguePlayerStats.ItemsSource = isSeason ? _lPSR : _plLpsr;
dgvMetricStats.ItemsSource = isSeason ? _psrList : _plPSRList;
dgvLeagueMetricStats.ItemsSource = isSeason ? _lPSR : _plLpsr;
dgvRatings.ItemsSource = isSeason ? _psrList : _plPSRList;
dgvContracts.ItemsSource = isSeason ? _psrList : _plPSRList;
dgvLeaders.ItemsSource = isSeason ? _leadersList : _plLeadersList;
dgvMyLeaders.ItemsSource = isSeason ? _myLeadersList : _plMyLeadersList;
populateSituationalsCombo();
updateUltimateTeamTextboxes(isSeason);
updateBestPerformersTextboxes(isSeason);
tbcLeagueOverview.Visibility = Visibility.Visible;
txbStatus.FontWeight = FontWeights.Normal;
txbStatus.Text = _message;
_sem.Release();
};
tbcLeagueOverview.Visibility = Visibility.Hidden;
worker1.RunWorkerAsync();
}
private void updateScoutingReport()
{
int id = _selectedPlayerID;
if (MainWindow.PST[id].Totals[PAbbr.GP] > 0)
{
grpSeasonScoutingReport.Visibility = Visibility.Visible;
grpSeasonFacts.Visibility = Visibility.Visible;
grpSeasonLeadersFacts.Visibility = Visibility.Visible;
string msg = new PlayerStatsRow(MainWindow.PST[id], false, false).ScoutingReport(MainWindow.PST,
_cumSeasonRankingsActive,
_cumSeasonRankingsTeam,
_cumSeasonRankingsPosition, _pbsList,
txbGame1.Text);
txbSeasonScoutingReport.Text = msg;
List<string> facts = GetFacts(id, _cumSeasonRankingsActive);
txbSeasonFacts.Text = aggregateFacts(facts);
if (facts.Count == 0)
{
grpSeasonFacts.Visibility = Visibility.Collapsed;
}
facts = GetFacts(id, MainWindow.SeasonLeadersRankings, true);
txbSeasonLeadersFacts.Text = aggregateFacts(facts);
if (facts.Count == 0)
{
grpSeasonLeadersFacts.Visibility = Visibility.Collapsed;
}
}
else
{
grpSeasonScoutingReport.Visibility = Visibility.Collapsed;
grpSeasonFacts.Visibility = Visibility.Collapsed;
grpSeasonLeadersFacts.Visibility = Visibility.Collapsed;
}
if (MainWindow.PST[id].PlTotals[PAbbr.GP] > 0)
{
grpPlayoffsScoutingReport.Visibility = Visibility.Visible;
grpPlayoffsFacts.Visibility = Visibility.Visible;
grpPlayoffsLeadersFacts.Visibility = Visibility.Visible;
string msg = new PlayerStatsRow(MainWindow.PST[id], true, false).ScoutingReport(MainWindow.PST,
_cumPlayoffsRankingsActive,
_cumPlayoffsRankingsTeam,
_cumPlayoffsRankingsPosition, _pbsList,
txbGame1.Text);
txbPlayoffsScoutingReport.Text = msg;
List<string> facts = GetFacts(id, _cumPlayoffsRankingsActive);
txbPlayoffsFacts.Text = aggregateFacts(facts);
if (facts.Count == 0)
{
grpPlayoffsFacts.Visibility = Visibility.Collapsed;
}
facts = GetFacts(id, MainWindow.PlayoffsLeadersRankings, true);
txbPlayoffsLeadersFacts.Text = aggregateFacts(facts);
if (facts.Count == 0)
{
grpPlayoffsLeadersFacts.Visibility = Visibility.Collapsed;
}
}
else
{
grpPlayoffsScoutingReport.Visibility = Visibility.Collapsed;
grpPlayoffsFacts.Visibility = Visibility.Collapsed;
grpPlayoffsLeadersFacts.Visibility = Visibility.Collapsed;
}
svScoutingReport.ScrollToTop();
}
private static void updateNotables()
{
Dictionary<int, PlayerStats> pstLeaders;
SeasonLeadersRankings = PlayerRankings.CalculateLeadersRankings(out pstLeaders);
_notables = new List<string>();
Dictionary<int, PlayerStats> temp;
PlayoffsLeadersRankings = PlayerRankings.CalculateLeadersRankings(out temp, true);
if (pstLeaders.Count == 0)
{
return;
}
var leadersPSRList = new List<PlayerStatsRow>();
pstLeaders.Values.ToList().ForEach(
delegate(PlayerStats ps)
{
var psr = new PlayerStatsRow(ps, calcRatings: false);
leadersPSRList.Add(psr);
});
var psrList = new Dictionary<int, PlayerStatsRow>();
PST.Values.ToList().ForEach(
delegate(PlayerStats ps)
{
var psr = new PlayerStatsRow(ps, calcRatings: false);
psrList.Add(psr.ID, psr);
});
//PlayerStatsRow curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.PPG).First().ID);
PlayerStatsRow curL;
string m, s;
float ppg;
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.PPG][1]];
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 3, PAbbrPG.PPG);
s = String.Format(
"PPG Leader: {0} {1} ({2}) ({3:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.PPG,
m);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.FGp).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.FGp][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.FGp);
s = String.Format(
"FG% Leader: {0} {1} ({2}) ({3:F3} FG%, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.FGp,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.RPG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.RPG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.RPG);
s = String.Format(
"RPG Leader: {0} {1} ({2}) ({3:F1} RPG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.RPG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.BPG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.BPG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.BPG);
s = String.Format(
"BPG Leader: {0} {1} ({2}) ({3:F1} BPG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.BPG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.APG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.APG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.APG);
s = String.Format(
"APG Leader: {0} {1} ({2}) ({3:F1} APG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.APG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.SPG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.SPG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.SPG);
s = String.Format(
"SPG Leader: {0} {1} ({2}) ({3:F1} SPG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.SPG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.ORPG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.ORPG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.ORPG);
s = String.Format(
"ORPG Leader: {0} {1} ({2}) ({3:F1} ORPG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.ORPG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.DRPG).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.DRPG][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.DRPG);
s = String.Format(
"DRPG Leader: {0} {1} ({2}) ({3:F1} DRPG, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.DRPG,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.TPp).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.TPp][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.TPp);
s = String.Format(
"3P% Leader: {0} {1} ({2}) ({3:F3} 3P%, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.TPp,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
//curL = psrList.Single(psr => psr.ID == leadersPSRList.OrderByDescending(pair => pair.FTp).First().ID);
try
{
curL = psrList[SeasonLeadersRankings.RevRankingsPerGame[PAbbrPG.FTp][1]];
ppg = double.IsNaN(curL.PPG) ? PST[curL.ID].PerGame[PAbbrPG.PPG] : curL.PPG;
m = getBestStatsForMarquee(curL, SeasonLeadersRankings, 2, PAbbrPG.FTp);
s = String.Format(
"FT% Leader: {0} {1} ({2}) ({3:F3} FT%, {5:F1} PPG, {4})",
curL.FirstName,
curL.LastName,
TST[curL.TeamF].DisplayName,
curL.FTp,
m,
ppg);
_notables.Add(s);
}
catch (KeyNotFoundException e)
{
Console.WriteLine(e);
}
if (_notables.Count > 0)
{
_notables.Shuffle();
MWInstance.txbMarquee.Text = "League Notables";
MWInstance._marqueeTimer.Start();
}
}
private static string getBestStatsForMarquee(PlayerStatsRow curLr, PlayerRankings rankingsActive, int count, int statToIgnore)
{
var s = "";
var dict = new Dictionary<int, int>();
for (var k = 0; k < rankingsActive.RankingsPerGame[curLr.ID].Length; k++)
{
dict.Add(k, rankingsActive.RankingsPerGame[curLr.ID][k]);
}
dict[PAbbrPG.FPG] = PST.Count + 1 - dict[PAbbrPG.FPG];
dict[PAbbrPG.TPG] = PST.Count + 1 - dict[PAbbrPG.TPG];
//dict[t.PAPG] = pst.Count + 1 - dict[t.PAPG];
var strengths = (from entry in dict orderby entry.Value ascending select entry.Key).ToList();
var m = 0;
var j = count;
while (true)
{
if (m == j)
{
break;
}
if (strengths[m] == statToIgnore || strengths[m] == PAbbrPG.PPG || strengths[m] == PAbbrPG.DRPG)
{
j++;
m++;
continue;
}
switch (strengths[m])
{
case PAbbrPG.APG:
s += String.Format("{0:F1} APG, ", curLr.APG);
break;
case PAbbrPG.BPG:
s += String.Format("{0:F1} BPG, ", curLr.BPG);
break;
case PAbbrPG.DRPG:
s += String.Format("{0:F1} DRPG, ", curLr.DRPG);
break;
case PAbbrPG.FGp:
s += String.Format("{0:F3} FG%, ", curLr.FGp);
break;
case PAbbrPG.FPG:
s += String.Format("{0:F1} FPG, ", curLr.FPG);
break;
case PAbbrPG.FTp:
s += String.Format("{0:F3} FT%, ", curLr.FTp);
break;
case PAbbrPG.ORPG:
s += String.Format("{0:F1} ORPG, ", curLr.ORPG);
break;
case PAbbrPG.PPG:
s += String.Format("{0:F1} PPG, ", curLr.PPG);
break;
case PAbbrPG.RPG:
s += String.Format("{0:F1} RPG, ", curLr.RPG);
break;
case PAbbrPG.SPG:
s += String.Format("{0:F1} SPG, ", curLr.SPG);
break;
case PAbbrPG.TPG:
s += String.Format("{0:F1} TPG, ", curLr.TPG);
break;
case PAbbrPG.TPp:
s += String.Format("{0:F3} 3P%, ", curLr.TPp);
break;
default:
j++;
break;
}
m++;
}
s = s.TrimEnd(new[] { ' ', ',' });
return s;
}
/// <summary>
/// Handles the SelectionChanged event of the cmbPlayer control.
/// Updates the PlayerStatsRow instance and all DataGrid controls with this player's information and stats.
/// </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 cmbPlayer_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (cmbPlayer.SelectedIndex == -1)
{
return;
}
_selectedPlayerID = ((KeyValuePair<int, string>) (((cmbPlayer)).SelectedItem)).Key;
_pbsList = new ObservableCollection<PlayerBoxScore>();
try
{
_psr = new PlayerStatsRow(MainWindow.PST[_selectedPlayerID]);
}
catch (Exception ex)
{
Console.WriteLine("Player with ID " + _selectedPlayerID + " couldn't be loaded: " + ex.Message);
cmbPlayer.SelectedIndex = -1;
return;
}
_plPSR = new PlayerStatsRow(MainWindow.PST[_selectedPlayerID], true);
updateOverviewAndBoxScores();
updateSplitStats();
updateYearlyReport();
_cumSeasonRankingsActive = PlayerRankings.CalculateActiveRankings();
_cumSeasonRankingsPosition =
new PlayerRankings(MainWindow.PST.Where(ps => ps.Value.Position1 == _psr.Position1)
.ToDictionary(r => r.Key, r => r.Value));
_cumSeasonRankingsTeam =
new PlayerRankings(MainWindow.PST.Where(ps => ps.Value.TeamF == _psr.TeamF).ToDictionary(r => r.Key, r => r.Value));
_cumPlayoffsRankingsActive = PlayerRankings.CalculateActiveRankings(true);
_cumPlayoffsRankingsPosition =
new PlayerRankings(
MainWindow.PST.Where(ps => ps.Value.Position1 == _psr.Position1).ToDictionary(r => r.Key, r => r.Value), true);
_cumPlayoffsRankingsTeam =
new PlayerRankings(MainWindow.PST.Where(ps => ps.Value.TeamF == _psr.TeamF).ToDictionary(r => r.Key, r => r.Value),
true);
updateScoutingReport();
updateRecords();
cmbOppPlayer_SelectionChanged(null, null);
if (cmbGraphStat.SelectedIndex == -1)
{
cmbGraphStat.SelectedIndex = 0;
}
}
/// <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>
/// 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;
}
public static void Refresh(ref PlayerStatsRow psr)
{
psr = new PlayerStatsRow(new PlayerStats(psr));
}
public PlayerStats ConvertToMyLeagueLeader(Dictionary<int, TeamStats> teamStats, bool playoffs = false)
{
var newpsr = new PlayerStatsRow(this, playoffs, calcRatings: false).ConvertToMyLeagueLeader(teamStats, playoffs);
return new PlayerStats(newpsr, playoffs);
}
/// <summary>
/// Tries to parse the specified dictionary and update the specified PlayerStatsRow instance.
/// </summary>
/// <param name="psr">The PSR.</param>
/// <param name="dict">The dict.</param>
public static void TryChangePSR(ref PlayerStatsRow psr, Dictionary<string, string> dict)
{
psr.GP = psr.GP.TrySetValue(dict, "GP", typeof (UInt16));
psr.GS = psr.GS.TrySetValue(dict, "GS", typeof (UInt16));
psr.MINS = psr.MINS.TrySetValue(dict, "MINS", typeof (UInt16));
psr.PTS = psr.PTS.TrySetValue(dict, "PTS", typeof (UInt16));
psr.FGM = psr.FGM.TrySetValue(dict, "FGM", typeof (UInt16));
psr.FGA = psr.FGA.TrySetValue(dict, "FGA", typeof (UInt16));
psr.TPM = psr.TPM.TrySetValue(dict, "3PM", typeof (UInt16));
psr.TPA = psr.TPA.TrySetValue(dict, "3PA", typeof (UInt16));
psr.FTM = psr.FTM.TrySetValue(dict, "FTM", typeof (UInt16));
psr.FTA = psr.FTA.TrySetValue(dict, "FTA", typeof (UInt16));
psr.REB = psr.REB.TrySetValue(dict, "REB", typeof (UInt16));
psr.OREB = psr.OREB.TrySetValue(dict, "OREB", typeof (UInt16));
psr.DREB = psr.DREB.TrySetValue(dict, "DREB", typeof (UInt16));
psr.AST = psr.AST.TrySetValue(dict, "AST", typeof (UInt16));
psr.TOS = psr.TOS.TrySetValue(dict, "TO", typeof (UInt16));
psr.STL = psr.STL.TrySetValue(dict, "STL", typeof (UInt16));
psr.BLK = psr.BLK.TrySetValue(dict, "BLK", typeof (UInt16));
psr.FOUL = psr.FOUL.TrySetValue(dict, "FOUL", typeof (UInt16));
}
private void updateGraph()
{
if (cmbGraphStat.SelectedIndex == -1 || cmbGraphInterval.SelectedIndex == -1 || cmbTeam.SelectedIndex == -1
|| cmbPlayer.SelectedIndex == -1)
{
clearGraph();
return;
}
var intervalItem = cmbGraphInterval.SelectedItem.ToString();
var yearlyStats = _yearlyPSRList.Where(psr => psr.Type.StartsWith("Season ")).ToList();
var monthlyStats = MainWindow.SplitPlayerStats[_psr.ID].Where(pair => pair.Key.StartsWith("M ")).ToList();
int count;
Intervals interval;
switch (intervalItem)
{
case "Every Game":
interval = Intervals.EveryGame;
count = _pbsListWithOut.Count;
break;
case "Monthly":
interval = Intervals.Monthly;
count = monthlyStats.Count;
break;
case "Yearly":
interval = Intervals.Yearly;
count = yearlyStats.Count;
break;
default:
throw new ArgumentOutOfRangeException();
}
if (count < 2)
{
clearGraph();
return;
}
var propToGet = cmbGraphStat.SelectedItem.ToString();
propToGet = propToGet.Replace('3', 'T');
propToGet = propToGet.Replace('%', 'p');
propToGet = propToGet.Replace("TO", "TOS");
double sum = 0;
double games = 0;
chart.Primitives.Clear();
var cp = new ChartPrimitive { Label = cmbGraphStat.SelectedItem.ToString(), ShowInLegend = false };
switch (interval)
{
case Intervals.EveryGame:
var orderedPBSList = _pbsListWithOut.OrderBy(pbs => pbs.RealDate).ToList();
for (var i = 0; i < orderedPBSList.Count; i++)
{
var pbs = orderedPBSList[i];
if (pbs.IsOut)
{
if (cp.Points.Count > 0)
{
chart.Primitives.Add(cp.CustomClone());
cp = new ChartPrimitive { Label = cmbGraphStat.SelectedItem.ToString(), ShowInLegend = false };
}
continue;
}
var value = Convert.ToDouble(typeof(PlayerBoxScore).GetProperty(propToGet).GetValue(pbs, null));
if (double.IsNaN(value))
{
continue;
}
if (propToGet.Contains("p"))
{
value = Convert.ToDouble(Convert.ToInt32(value * 1000)) / 1000;
}
cp.AddPoint(i + 1, value);
games++;
sum += value;
}
break;
case Intervals.Monthly:
case Intervals.Yearly:
if (interval == Intervals.Monthly)
{
monthlyStats = monthlyStats.OrderBy(ms => ms.Key).ToList();
}
if (PlayerStatsHelper.TotalsToPerGame.ContainsKey(propToGet))
{
propToGet = PlayerStatsHelper.TotalsToPerGame[propToGet];
}
for (var i = 0; i < count; i ++)
{
var ps = interval == Intervals.Monthly ? monthlyStats[i].Value : new PlayerStats(yearlyStats[i]);
if (ps.Totals[PAbbrT.GP] == 0)
{
if (cp.Points.Count > 0)
{
chart.Primitives.Add(cp.CustomClone());
cp = new ChartPrimitive { Label = cmbGraphStat.SelectedItem.ToString(), ShowInLegend = false };
}
continue;
}
var dummyTs = new TeamStats();
ps.CalcMetrics(dummyTs, dummyTs, dummyTs, GmScOnly: true);
var psr = new PlayerStatsRow(ps, calcRatings: false);
var value = psr.GetValue<double>(propToGet);
if (double.IsNaN(value))
{
continue;
}
if (propToGet.Contains("p"))
{
value = Convert.ToDouble(Convert.ToInt32(value * 1000)) / 1000;
}
cp.AddPoint(i + 1, value);
games++;
sum += value;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (cp.Points.Count > 0)
{
chart.Primitives.Add(cp.CustomClone());
}
if (chart.Primitives.Count > 0 && chart.Primitives.Sum(p => p.Points.Count) > 1)
{
if (PlayerStatsHelper.TotalsToPerGame.ContainsKey(propToGet))
{
propToGet = PlayerStatsHelper.TotalsToPerGame[propToGet];
}
double average;
switch (interval)
{
case Intervals.EveryGame:
case Intervals.Monthly:
average = _psr.GetValue<double>(propToGet);
break;
case Intervals.Yearly:
average = _yearlyPSRList.Last().GetValue<double>(propToGet);
break;
default:
throw new ArgumentOutOfRangeException();
}
//var average = sum / games;
var cpavg = new ChartPrimitive();
for (var i = 0; i < count; i++)
{
cpavg.AddPoint(i + 1, average);
}
cpavg.Color = Color.FromRgb(0, 0, 100);
cpavg.Dashed = true;
cpavg.ShowInLegend = false;
var cp2 = new ChartPrimitive();
cp2.AddPoint(chart.Primitives.First().Points.First().X, 0);
cp2.AddPoint(chart.Primitives.Last().Points.Last().X, 1);
chart.Primitives.Add(cpavg);
chart.RedrawPlotLines();
chart.Primitives.Add(cp2);
}
else
{
chart.RedrawPlotLines();
var cp2 = new ChartPrimitive();
cp2.AddPoint(1, 0);
cp2.AddPoint(2, 1);
chart.Primitives.Add(cp2);
}
chart.ResetPanAndZoom();
}
