/// <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;
DataSet ds = getSeasonTeamStats(@"http://www.basketball-reference.com/teams/" + teamAbbr.Value + @"/2013.html",
out recordparts);
teamStatsFromDataTable(ds.Tables[0], teamAbbr.Key, recordparts, out ts, out tsopp);
ds = getPlayerStats(@"http://www.basketball-reference.com/teams/" + teamAbbr.Value + @"/2013.html");
playerStatsFromDataSet(ds, ts.ID, out pst);
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow" /> class. Creates the program's documents directories if needed,
/// initializes structures, and loads the settings from registry.
/// </summary>
public MainWindow()
{
InitializeComponent();
MWInstance = this;
TempBSE_BS = new TeamBoxScore();
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
setDefaultCulture(CultureInfo.CreateSpecificCulture("en-US"));
//btnInject.Visibility = Visibility.Hidden;
#if DEBUG
btnTest.Visibility = Visibility.Visible;
#else
btnTest.Visibility = Visibility.Hidden;
#endif
if (Directory.Exists(PSFiltersPath) == false)
{
Directory.CreateDirectory(PSFiltersPath);
}
if (Directory.Exists(ASCFiltersPath) == false)
{
Directory.CreateDirectory(ASCFiltersPath);
}
var appTempPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\NBA Stats Tracker\" + @"Temp\";
if (Directory.Exists(appTempPath) == false)
{
Directory.CreateDirectory(appTempPath);
}
TST[0] = new TeamStats(-1, "$$NewDB");
TSTOpp[0] = new TeamStats(-1, "$$NewDB");
for (var i = 0; i < 30; i++)
{
RealTST[i] = new TeamStats();
}
RegistryKey rk = null;
try
{
rk = Registry.CurrentUser;
}
catch (Exception ex)
{
App.ForceCriticalError(ex, "Registry.CurrentUser");
}
Debug.Assert(rk != null, "rk != null");
rk = rk.OpenSubKey(@"SOFTWARE\2K Sports\NBA 2K12");
if (rk == null)
{
SavesPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\2K Sports\NBA 2K12\Saves\";
}
else
{
try
{
SavesPath = rk.GetValue("Saves").ToString();
}
catch (Exception)
{
SavesPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\2K Sports\NBA 2K12\Saves\";
}
}
CSV.ReplaceREDitorSortingChars = true;
if (App.RealNBAOnly)
{
mnuFileGetRealStats_Click(null, null);
MessageBox.Show("Nothing but net! Thanks for using NBA Stats Tracker!");
Environment.Exit(-1);
}
else
{
var exportTeamsOnly = Tools.GetRegistrySetting("ExportTeamsOnly", 1);
mnuOptionsExportTeamsOnly.IsChecked = exportTeamsOnly == 1;
var compatibilityCheck = Tools.GetRegistrySetting("CompatibilityCheck", 1);
mnuOptionsCompatibilityCheck.IsChecked = compatibilityCheck == 1;
IsImperial = Tools.GetRegistrySetting("IsImperial", 1) == 1;
mnuOptionsIsImperial.IsChecked = IsImperial;
// Displays a message to urge the user to donate at the 50th start of the program.
var timesStarted = Tools.GetRegistrySetting("TimesStarted", -1);
if (timesStarted == -1)
{
Tools.SetRegistrySetting("TimesStarted", 1);
}
else if (timesStarted <= 50)
{
if (timesStarted == 50)
{
var r =
MessageBox.Show(
"Hey there! This is a friendly reminder from the creator of NBA Stats Tracker.\n\n"
+ "You seem to like using NBA Stats Tracker a lot, and I'm sure you enjoy the fact that it's free. "
+ "However, if you believe that I deserve your support and you want to help me to continue my studies, "
+ "as well as continue developing and supporting NBA Stats Tracker, you can always donate!\n\n"
+ "Even a small amount can help a lot!\n\n" + "Would you like to find out how you can donate?\n\n"
+ "Clicking Cancel will make sure this message never shows up again.",
"NBA Stats Tracker - A friendly reminder",
MessageBoxButton.YesNoCancel,
MessageBoxImage.Information);
if (r == MessageBoxResult.Yes)
{
mnuHelpDonate_Click(null, null);
}
else if (r == MessageBoxResult.No)
{
timesStarted = -1;
}
}
Tools.SetRegistrySetting("TimesStarted", timesStarted + 1);
}
}
UIScheduler = TaskScheduler.FromCurrentSynchronizationContext();
SearchCache = new List<SearchItem>();
#region Keyboard Shortcuts
CmndImport.InputGestures.Add(new KeyGesture(Key.I, ModifierKeys.Control));
CommandBindings.Add(new CommandBinding(CmndImport, btnImport2K12_Click));
CmndExport.InputGestures.Add(new KeyGesture(Key.E, ModifierKeys.Control));
CommandBindings.Add(new CommandBinding(CmndExport, btnExport2K12_Click));
CmndOpen.InputGestures.Add(new KeyGesture(Key.O, ModifierKeys.Control));
CommandBindings.Add(new CommandBinding(CmndOpen, btnOpen_Click));
CmndSave.InputGestures.Add(new KeyGesture(Key.S, ModifierKeys.Control));
CommandBindings.Add(new CommandBinding(CmndSave, btnSaveCurrentSeason_Click));
CmndFind.InputGestures.Add(new KeyGesture(Key.F, ModifierKeys.Control));
CommandBindings.Add(new CommandBinding(CmndFind, QuickFind));
#endregion
//prepareImageCache();
}
/// <summary>Adds the team stats from a TeamStats instance to the current stats.</summary>
/// <param name="rhs">The team stats to add.</param>
/// <param name="mode">The time-span.</param>
/// <exception cref="System.Exception">Team Add Stats called with invalid parameter.</exception>
public void AddTeamStats(TeamStats rhs, Span mode)
{
switch (mode)
{
case Span.Season:
{
Record[0] += rhs.Record[0];
Record[1] += rhs.Record[1];
for (var i = 0; i < Totals.Length; i++)
{
Totals[i] += rhs.Totals[i];
}
CalcAvg();
break;
}
case Span.Playoffs:
{
PlRecord[0] += rhs.PlRecord[0];
PlRecord[1] += rhs.PlRecord[1];
for (var i = 0; i < PlTotals.Length; i++)
{
PlTotals[i] += rhs.PlTotals[i];
}
CalcAvg();
break;
}
case Span.SeasonAndPlayoffsToSeason:
{
Record[0] += rhs.Record[0];
Record[1] += rhs.Record[1];
for (var i = 0; i < Totals.Length; i++)
{
Totals[i] += rhs.Totals[i];
}
Record[0] += rhs.PlRecord[0];
Record[1] += rhs.PlRecord[1];
for (var i = 0; i < PlTotals.Length; i++)
{
Totals[i] += rhs.PlTotals[i];
}
CalcAvg();
break;
}
case Span.SeasonAndPlayoffs:
{
AddTeamStats(rhs, Span.Season);
AddTeamStats(rhs, Span.Playoffs);
break;
}
default:
{
throw new Exception("Team Add Stats called with invalid parameter: " + mode);
}
}
}
/// <summary>Adds the team stats from a box score.</summary>
/// <param name="bsToAdd">The box score to add.</param>
/// <param name="ts1">The first team's team stats.</param>
/// <param name="ts2">The second team's team stats.</param>
/// <param name="ignorePlayoffFlag">Whether to ignore the playoff flag in the box score and add the stats to the season totals.</param>
public static void AddTeamStatsFromBoxScore(
TeamBoxScore bsToAdd, ref TeamStats ts1, ref TeamStats ts2, bool ignorePlayoffFlag = false)
{
var tst = new Dictionary<int, TeamStats> { { 1, ts1 }, { 2, ts2 } };
var tstOpp = new Dictionary<int, TeamStats> { { 1, new TeamStats() }, { 2, new TeamStats() } };
AddTeamStatsFromBoxScore(bsToAdd, ref tst, ref tstOpp, 1, 2, ignorePlayoffFlag);
ts1 = tst[1];
ts2 = tst[2];
}
/// <summary>Adds a box score resulting from an SQLite query to a TeamStats instance.</summary>
/// <param name="r">The result of the query containing the box score record.</param>
/// <param name="ts">The TeamStats instance to be modified.</param>
/// <param name="tsopp">The opposing TeamStats instance to be modified.</param>
private static void addToTeamStatsFromSQLBoxScore(DataRow r, ref TeamStats ts, ref TeamStats tsopp)
{
var playoffs = ParseCell.GetBoolean(r, "isPlayoff");
if (!playoffs)
{
var t1PTS = Convert.ToInt32(r["T1PTS"].ToString());
var t2PTS = Convert.ToInt32(r["T2PTS"].ToString());
if (r["T1Name"].ToString().Equals(ts.Name))
{
if (t1PTS > t2PTS)
{
ts.Record[0]++;
}
else
{
ts.Record[1]++;
}
tsopp.Totals[TAbbrT.MINS] = ts.Totals[TAbbrT.MINS] += Convert.ToUInt16(r["T1MINS"].ToString());
tsopp.Totals[TAbbrT.PA] = ts.Totals[TAbbrT.PF] += Convert.ToUInt16(r["T1PTS"].ToString());
tsopp.Totals[TAbbrT.PF] = ts.Totals[TAbbrT.PA] += Convert.ToUInt16(r["T2PTS"].ToString());
ts.Totals[TAbbrT.FGM] += Convert.ToUInt16(r["T1FGM"].ToString());
ts.Totals[TAbbrT.FGA] += Convert.ToUInt16(r["T1FGA"].ToString());
ts.Totals[TAbbrT.TPM] += Convert.ToUInt16(r["T13PM"].ToString());
ts.Totals[TAbbrT.TPA] += Convert.ToUInt16(r["T13PA"].ToString());
ts.Totals[TAbbrT.FTM] += Convert.ToUInt16(r["T1FTM"].ToString());
ts.Totals[TAbbrT.FTA] += Convert.ToUInt16(r["T1FTA"].ToString());
var t1REB = Convert.ToUInt16(r["T1REB"].ToString());
var t1OREB = Convert.ToUInt16(r["T1OREB"].ToString());
ts.Totals[TAbbrT.DREB] += (ushort) (t1REB - t1OREB);
ts.Totals[TAbbrT.OREB] += t1OREB;
ts.Totals[TAbbrT.STL] += Convert.ToUInt16(r["T1STL"].ToString());
ts.Totals[TAbbrT.TOS] += Convert.ToUInt16(r["T1TOS"].ToString());
ts.Totals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T1BLK");
ts.Totals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T1AST");
ts.Totals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T1FOUL");
tsopp.Totals[TAbbrT.FGM] += Convert.ToUInt16(r["T2FGM"].ToString());
tsopp.Totals[TAbbrT.FGA] += Convert.ToUInt16(r["T2FGA"].ToString());
tsopp.Totals[TAbbrT.TPM] += Convert.ToUInt16(r["T23PM"].ToString());
tsopp.Totals[TAbbrT.TPA] += Convert.ToUInt16(r["T23PA"].ToString());
tsopp.Totals[TAbbrT.FTM] += Convert.ToUInt16(r["T2FTM"].ToString());
tsopp.Totals[TAbbrT.FTA] += Convert.ToUInt16(r["T2FTA"].ToString());
var t2REB = Convert.ToUInt16(r["T2REB"].ToString());
var t2OREB = Convert.ToUInt16(r["T2OREB"].ToString());
tsopp.Totals[TAbbrT.DREB] += (ushort) (t2REB - t2OREB);
tsopp.Totals[TAbbrT.OREB] += t2OREB;
tsopp.Totals[TAbbrT.STL] += Convert.ToUInt16(r["T2STL"].ToString());
tsopp.Totals[TAbbrT.TOS] += Convert.ToUInt16(r["T2TOS"].ToString());
tsopp.Totals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T2BLK");
tsopp.Totals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T2AST");
tsopp.Totals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T2FOUL");
}
else
{
if (t2PTS > t1PTS)
{
ts.Record[0]++;
}
else
{
ts.Record[1]++;
}
tsopp.Totals[TAbbrT.MINS] = ts.Totals[TAbbrT.MINS] += Convert.ToUInt16(r["T2MINS"].ToString());
tsopp.Totals[TAbbrT.PA] = ts.Totals[TAbbrT.PF] += Convert.ToUInt16(r["T2PTS"].ToString());
tsopp.Totals[TAbbrT.PF] = ts.Totals[TAbbrT.PA] += Convert.ToUInt16(r["T1PTS"].ToString());
ts.Totals[TAbbrT.FGM] += Convert.ToUInt16(r["T2FGM"].ToString());
ts.Totals[TAbbrT.FGA] += Convert.ToUInt16(r["T2FGA"].ToString());
ts.Totals[TAbbrT.TPM] += Convert.ToUInt16(r["T23PM"].ToString());
ts.Totals[TAbbrT.TPA] += Convert.ToUInt16(r["T23PA"].ToString());
ts.Totals[TAbbrT.FTM] += Convert.ToUInt16(r["T2FTM"].ToString());
ts.Totals[TAbbrT.FTA] += Convert.ToUInt16(r["T2FTA"].ToString());
var t2REB = Convert.ToUInt16(r["T2REB"].ToString());
var t2OREB = Convert.ToUInt16(r["T2OREB"].ToString());
ts.Totals[TAbbrT.DREB] += (ushort) (t2REB - t2OREB);
ts.Totals[TAbbrT.OREB] += t2OREB;
ts.Totals[TAbbrT.STL] += Convert.ToUInt16(r["T2STL"].ToString());
ts.Totals[TAbbrT.TOS] += Convert.ToUInt16(r["T2TOS"].ToString());
ts.Totals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T2BLK");
ts.Totals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T2AST");
ts.Totals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T2FOUL");
tsopp.Totals[TAbbrT.FGM] += Convert.ToUInt16(r["T1FGM"].ToString());
tsopp.Totals[TAbbrT.FGA] += Convert.ToUInt16(r["T1FGA"].ToString());
tsopp.Totals[TAbbrT.TPM] += Convert.ToUInt16(r["T13PM"].ToString());
tsopp.Totals[TAbbrT.TPA] += Convert.ToUInt16(r["T13PA"].ToString());
tsopp.Totals[TAbbrT.FTM] += Convert.ToUInt16(r["T1FTM"].ToString());
tsopp.Totals[TAbbrT.FTA] += Convert.ToUInt16(r["T1FTA"].ToString());
var t1REB = Convert.ToUInt16(r["T1REB"].ToString());
var t1OREB = Convert.ToUInt16(r["T1OREB"].ToString());
tsopp.Totals[TAbbrT.DREB] += (ushort) (t1REB - t1OREB);
tsopp.Totals[TAbbrT.OREB] += t1OREB;
tsopp.Totals[TAbbrT.STL] += Convert.ToUInt16(r["T1STL"].ToString());
tsopp.Totals[TAbbrT.TOS] += Convert.ToUInt16(r["T1TOS"].ToString());
tsopp.Totals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T1BLK");
tsopp.Totals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T1AST");
tsopp.Totals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T1FOUL");
}
tsopp.Record[1] = ts.Record[0];
tsopp.Record[0] = ts.Record[1];
}
else
{
var t1PTS = Convert.ToInt32(r["T1PTS"].ToString());
var t2PTS = Convert.ToInt32(r["T2PTS"].ToString());
if (r["T1Name"].ToString().Equals(ts.Name))
{
if (t1PTS > t2PTS)
{
ts.PlRecord[0]++;
}
else
{
ts.PlRecord[1]++;
}
tsopp.PlTotals[TAbbrT.MINS] = ts.PlTotals[TAbbrT.MINS] += Convert.ToUInt16(r["T1MINS"].ToString());
tsopp.PlTotals[TAbbrT.PA] = ts.PlTotals[TAbbrT.PF] += Convert.ToUInt16(r["T1PTS"].ToString());
tsopp.PlTotals[TAbbrT.PF] = ts.PlTotals[TAbbrT.PA] += Convert.ToUInt16(r["T2PTS"].ToString());
ts.PlTotals[TAbbrT.FGM] += Convert.ToUInt16(r["T1FGM"].ToString());
ts.PlTotals[TAbbrT.FGA] += Convert.ToUInt16(r["T1FGA"].ToString());
ts.PlTotals[TAbbrT.TPM] += Convert.ToUInt16(r["T13PM"].ToString());
ts.PlTotals[TAbbrT.TPA] += Convert.ToUInt16(r["T13PA"].ToString());
ts.PlTotals[TAbbrT.FTM] += Convert.ToUInt16(r["T1FTM"].ToString());
ts.PlTotals[TAbbrT.FTA] += Convert.ToUInt16(r["T1FTA"].ToString());
var t1REB = Convert.ToUInt16(r["T1REB"].ToString());
var t1OREB = Convert.ToUInt16(r["T1OREB"].ToString());
ts.PlTotals[TAbbrT.DREB] += (ushort) (t1REB - t1OREB);
ts.PlTotals[TAbbrT.OREB] += t1OREB;
ts.PlTotals[TAbbrT.STL] += Convert.ToUInt16(r["T1STL"].ToString());
ts.PlTotals[TAbbrT.TOS] += Convert.ToUInt16(r["T1TOS"].ToString());
ts.PlTotals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T1BLK");
ts.PlTotals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T1AST");
ts.PlTotals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T1FOUL");
tsopp.PlTotals[TAbbrT.FGM] += Convert.ToUInt16(r["T2FGM"].ToString());
tsopp.PlTotals[TAbbrT.FGA] += Convert.ToUInt16(r["T2FGA"].ToString());
tsopp.PlTotals[TAbbrT.TPM] += Convert.ToUInt16(r["T23PM"].ToString());
tsopp.PlTotals[TAbbrT.TPA] += Convert.ToUInt16(r["T23PA"].ToString());
tsopp.PlTotals[TAbbrT.FTM] += Convert.ToUInt16(r["T2FTM"].ToString());
tsopp.PlTotals[TAbbrT.FTA] += Convert.ToUInt16(r["T2FTA"].ToString());
var t2REB = Convert.ToUInt16(r["T2REB"].ToString());
var t2OREB = Convert.ToUInt16(r["T2OREB"].ToString());
tsopp.PlTotals[TAbbrT.DREB] += (ushort) (t2REB - t2OREB);
tsopp.PlTotals[TAbbrT.OREB] += t2OREB;
tsopp.PlTotals[TAbbrT.STL] += Convert.ToUInt16(r["T2STL"].ToString());
tsopp.PlTotals[TAbbrT.TOS] += Convert.ToUInt16(r["T2TOS"].ToString());
tsopp.PlTotals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T2BLK");
tsopp.PlTotals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T2AST");
tsopp.PlTotals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T2FOUL");
}
else
{
if (t2PTS > t1PTS)
{
ts.PlRecord[0]++;
}
else
{
ts.PlRecord[1]++;
}
tsopp.PlTotals[TAbbrT.MINS] = ts.PlTotals[TAbbrT.MINS] += Convert.ToUInt16(r["T2MINS"].ToString());
tsopp.PlTotals[TAbbrT.PA] = ts.PlTotals[TAbbrT.PF] += Convert.ToUInt16(r["T2PTS"].ToString());
tsopp.PlTotals[TAbbrT.PF] = ts.PlTotals[TAbbrT.PA] += Convert.ToUInt16(r["T1PTS"].ToString());
ts.PlTotals[TAbbrT.FGM] += Convert.ToUInt16(r["T2FGM"].ToString());
ts.PlTotals[TAbbrT.FGA] += Convert.ToUInt16(r["T2FGA"].ToString());
ts.PlTotals[TAbbrT.TPM] += Convert.ToUInt16(r["T23PM"].ToString());
ts.PlTotals[TAbbrT.TPA] += Convert.ToUInt16(r["T23PA"].ToString());
ts.PlTotals[TAbbrT.FTM] += Convert.ToUInt16(r["T2FTM"].ToString());
ts.PlTotals[TAbbrT.FTA] += Convert.ToUInt16(r["T2FTA"].ToString());
var t2REB = Convert.ToUInt16(r["T2REB"].ToString());
var t2OREB = Convert.ToUInt16(r["T2OREB"].ToString());
ts.PlTotals[TAbbrT.DREB] += (ushort) (t2REB - t2OREB);
ts.PlTotals[TAbbrT.OREB] += t2OREB;
ts.PlTotals[TAbbrT.STL] += Convert.ToUInt16(r["T2STL"].ToString());
ts.PlTotals[TAbbrT.TOS] += Convert.ToUInt16(r["T2TOS"].ToString());
ts.PlTotals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T2BLK");
ts.PlTotals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T2AST");
ts.PlTotals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T2FOUL");
tsopp.PlTotals[TAbbrT.FGM] += Convert.ToUInt16(r["T1FGM"].ToString());
tsopp.PlTotals[TAbbrT.FGA] += Convert.ToUInt16(r["T1FGA"].ToString());
tsopp.PlTotals[TAbbrT.TPM] += Convert.ToUInt16(r["T13PM"].ToString());
tsopp.PlTotals[TAbbrT.TPA] += Convert.ToUInt16(r["T13PA"].ToString());
tsopp.PlTotals[TAbbrT.FTM] += Convert.ToUInt16(r["T1FTM"].ToString());
tsopp.PlTotals[TAbbrT.FTA] += Convert.ToUInt16(r["T1FTA"].ToString());
var t1REB = Convert.ToUInt16(r["T1REB"].ToString());
var t1OREB = Convert.ToUInt16(r["T1OREB"].ToString());
tsopp.PlTotals[TAbbrT.DREB] += (ushort) (t1REB - t1OREB);
tsopp.PlTotals[TAbbrT.OREB] += t1OREB;
tsopp.PlTotals[TAbbrT.STL] += Convert.ToUInt16(r["T1STL"].ToString());
tsopp.PlTotals[TAbbrT.TOS] += Convert.ToUInt16(r["T1TOS"].ToString());
tsopp.PlTotals[TAbbrT.BLK] += ParseCell.GetUInt16(r, "T1BLK");
tsopp.PlTotals[TAbbrT.AST] += ParseCell.GetUInt16(r, "T1AST");
tsopp.PlTotals[TAbbrT.FOUL] += ParseCell.GetUInt16(r, "T1FOUL");
}
tsopp.PlRecord[1] = ts.PlRecord[0];
tsopp.PlRecord[0] = ts.PlRecord[1];
}
ts.CalcAvg();
tsopp.CalcAvg();
}
/// <summary>Determines whether a specific team should be shown or not, based on the current filter.</summary>
/// <param name="ts">The team's TeamStats instance.</param>
/// <returns>true if it should be shown; otherwise, false</returns>
private bool inCurrentFilter(TeamStats ts)
{
if (_filterType == TeamFilter.League)
{
return true;
}
if (_filterType == TeamFilter.Conference)
{
var confID = -1;
foreach (var conf in MainWindow.Conferences)
{
if (conf.Name == _filterDescription)
{
confID = conf.ID;
break;
}
}
var div = MainWindow.Divisions.Find(division => division.ID == ts.Division);
if (div.ConferenceID == confID)
{
return true;
}
else
{
return false;
}
}
else
{
var div = MainWindow.Divisions.Find(division => division.ID == ts.Division);
if (div.Name == _filterDescription)
{
return true;
}
else
{
return false;
}
}
}
/// <summary>Prepares the presentation fields of the class.</summary>
/// <param name="teamID">The team.</param>
public void PrepareForDisplay(Dictionary<int, TeamStats> tst, int teamID)
{
FGp1 = (float) FGM1 / FGA1;
TPp1 = (float) TPM1 / TPA1;
FTp1 = (float) FTM1 / FTA1;
FGp2 = (float) FGM2 / FGA2;
TPp2 = (float) TPM2 / TPA2;
FTp2 = (float) FTM2 / FTA2;
DREB1 = (ushort) (REB1 - OREB1);
DREB2 = (ushort) (REB2 - OREB2);
if (teamID == Team1ID)
{
DisplayTeam = tst[Team1ID].DisplayName;
DisplayOpponent = tst[Team2ID].DisplayName;
DisplayLocation = "Away";
DisplayResult = PTS1 > PTS2 ? "W " : "L ";
DisplayREB = REB1;
DisplayOREB = OREB1;
DisplayAST = AST1;
DisplayTO = TOS1;
DisplayBLK = BLK1;
DisplaySTL = STL1;
DisplayFOUL = FOUL1;
FGp = FGp1;
TPp = TPp1;
FTp = FTp1;
var temp = new TeamStats();
var tempopp = new TeamStats();
TeamStats.AddTeamStatsFromBoxScore(this, ref temp, ref tempopp);
temp.CalcMetrics(tempopp);
tempopp.CalcMetrics(temp);
DisplayGmSc = temp.Metrics["GmSc"];
GmSc1 = temp.Metrics["GmSc"];
GmSc2 = tempopp.Metrics["GmSc"];
}
else
{
DisplayTeam = tst[Team2ID].DisplayName;
DisplayOpponent = tst[Team1ID].DisplayName;
DisplayLocation = "Home";
DisplayResult = PTS1 < PTS2 ? "W " : "L ";
DisplayREB = REB2;
DisplayOREB = OREB2;
DisplayAST = AST2;
DisplayTO = TOS2;
DisplayBLK = BLK2;
DisplaySTL = STL2;
DisplayFOUL = FOUL2;
FGp = FGp2;
TPp = TPp2;
FTp = FTp2;
var temp = new TeamStats();
var tempopp = new TeamStats();
TeamStats.AddTeamStatsFromBoxScore(this, ref tempopp, ref temp);
temp.CalcMetrics(tempopp);
tempopp.CalcMetrics(temp);
DisplayGmSc = temp.Metrics["GmSc"];
GmSc2 = temp.Metrics["GmSc"];
GmSc1 = tempopp.Metrics["GmSc"];
}
DisplayResult += PTS1 + "-" + PTS2;
}
/// <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)
{
ts = new TeamStats(MainWindow.TST.Single(pair => pair.Value.Name == name).Key, name);
tsopp = new TeamStats(MainWindow.TST.Single(pair => pair.Value.Name == name).Key, name);
tsopp.Record[1] = ts.Record[0] = Convert.ToByte(recordparts[0]);
tsopp.Record[0] = ts.Record[1] = Convert.ToByte(recordparts[1]);
DataRow tr = dt.Rows[0];
DataRow toppr = dt.Rows[2];
ts.Totals[TAbbr.MINS] = (ushort) (ParseCell.GetUInt16(tr, "MP")/5);
ts.Totals[TAbbr.FGM] = ParseCell.GetUInt16(tr, "FG");
ts.Totals[TAbbr.FGA] = ParseCell.GetUInt16(tr, "FGA");
ts.Totals[TAbbr.TPM] = ParseCell.GetUInt16(tr, "3P");
ts.Totals[TAbbr.TPA] = ParseCell.GetUInt16(tr, "3PA");
ts.Totals[TAbbr.FTM] = ParseCell.GetUInt16(tr, "FT");
ts.Totals[TAbbr.FTA] = ParseCell.GetUInt16(tr, "FTA");
ts.Totals[TAbbr.OREB] = ParseCell.GetUInt16(tr, "ORB");
ts.Totals[TAbbr.DREB] = ParseCell.GetUInt16(tr, "DRB");
ts.Totals[TAbbr.AST] = ParseCell.GetUInt16(tr, "AST");
ts.Totals[TAbbr.STL] = ParseCell.GetUInt16(tr, "STL");
ts.Totals[TAbbr.BLK] = ParseCell.GetUInt16(tr, "BLK");
ts.Totals[TAbbr.TOS] = ParseCell.GetUInt16(tr, "TOV");
ts.Totals[TAbbr.FOUL] = ParseCell.GetUInt16(tr, "PF");
ts.Totals[TAbbr.PF] = ParseCell.GetUInt16(tr, "PTS");
ts.Totals[TAbbr.PA] = ParseCell.GetUInt16(toppr, "PTS");
ts.CalcAvg();
tsopp.Totals[TAbbr.MINS] = (ushort) (ParseCell.GetUInt16(toppr, "MP")/5);
tsopp.Totals[TAbbr.FGM] = ParseCell.GetUInt16(toppr, "FG");
tsopp.Totals[TAbbr.FGA] = ParseCell.GetUInt16(toppr, "FGA");
tsopp.Totals[TAbbr.TPM] = ParseCell.GetUInt16(toppr, "3P");
tsopp.Totals[TAbbr.TPA] = ParseCell.GetUInt16(toppr, "3PA");
tsopp.Totals[TAbbr.FTM] = ParseCell.GetUInt16(toppr, "FT");
tsopp.Totals[TAbbr.FTA] = ParseCell.GetUInt16(toppr, "FTA");
tsopp.Totals[TAbbr.OREB] = ParseCell.GetUInt16(toppr, "ORB");
tsopp.Totals[TAbbr.DREB] = ParseCell.GetUInt16(toppr, "DRB");
tsopp.Totals[TAbbr.AST] = ParseCell.GetUInt16(toppr, "AST");
tsopp.Totals[TAbbr.STL] = ParseCell.GetUInt16(toppr, "STL");
tsopp.Totals[TAbbr.BLK] = ParseCell.GetUInt16(toppr, "BLK");
tsopp.Totals[TAbbr.TOS] = ParseCell.GetUInt16(toppr, "TOV");
tsopp.Totals[TAbbr.FOUL] = ParseCell.GetUInt16(toppr, "PF");
tsopp.Totals[TAbbr.PF] = ParseCell.GetUInt16(toppr, "PTS");
tsopp.Totals[TAbbr.PA] = ParseCell.GetUInt16(tr, "PTS");
tsopp.CalcAvg();
}
/// <summary>Updates the metric stats for the specified team's players.</summary>
/// <param name="team">1 if the away team's players' metric stats should be updated; anything else for the home team.</param>
private void updateMetric(int team)
{
var ts = new TeamStats(-1, team == 1 ? cmbTeam1.SelectedItem.ToString() : cmbTeam2.SelectedItem.ToString());
var tsopp = new TeamStats(-1, team == 1 ? cmbTeam2.SelectedItem.ToString() : cmbTeam1.SelectedItem.ToString());
tryParseBS();
if (!MainWindow.TempBSE_BS.Done)
{
return;
}
var bs = MainWindow.TempBSE_BS;
if (team == 1)
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref ts, ref tsopp);
}
else
{
TeamStats.AddTeamStatsFromBoxScore(bs, ref tsopp, ref ts);
}
ts.CalcMetrics(tsopp);
tsopp.CalcMetrics(ts);
var ls = new TeamStats(-1);
ls.AddTeamStats(ts, Span.SeasonAndPlayoffsToSeason);
ls.AddTeamStats(tsopp, Span.SeasonAndPlayoffsToSeason);
var pmsrList = new List<PlayerStatsRow>();
var pbsList = team == 1 ? pbsAwayList : pbsHomeList;
foreach (var pbs in pbsList)
{
if (pbs.PlayerID == -1)
{
continue;
}
var ps = _pst[pbs.PlayerID].BinarySerializationClone();
ps.ResetStats();
ps.AddBoxScore(pbs, bs.IsPlayoff);
ps.CalcMetrics(ts, tsopp, ls);
pmsrList.Add(new PlayerStatsRow(ps));
}
pmsrList.Sort((pmsr1, pmsr2) => pmsr1.GmSc.CompareTo(pmsr2.GmSc));
pmsrList.Reverse();
var tsr = new TeamStatsRow(ts);
if (team == 1)
{
_psrListAway = new List<PlayerStatsRow>(pmsrList);
dgvAwayPlayerMetricStats.ItemsSource = _psrListAway;
dgvAwayTeamMetricStats.ItemsSource = new[] { tsr };
}
else
{
_psrListHome = new List<PlayerStatsRow>(pmsrList);
dgvHomePlayerMetricStats.ItemsSource = _psrListHome;
dgvHomeTeamMetricStats.ItemsSource = new[] { tsr };
}
}
/// <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>Calculates all metrics.</summary>
/// <param name="playerStats">The player stats.</param>
/// <param name="teamStats">The team stats.</param>
/// <param name="oppStats">The opposing team stats.</param>
/// <param name="leagueOv">
/// set to <c>true</c> if calling from the LeagueOverview window.
/// </param>
/// <param name="playoffs">
/// if set to <c>true</c>, the metrics will be calculated for the playoff stats.
/// </param>
/// <param name="teamsPerPlayer">
/// if set to <c>true</c>, the team stats dictionary is assumed to be per player.
/// </param>
public static void CalculateAllMetrics(
ref Dictionary<int, PlayerStats> playerStats,
Dictionary<int, TeamStats> teamStats,
Dictionary<int, TeamStats> oppStats,
bool leagueOv = false,
bool playoffs = false,
bool teamsPerPlayer = false)
{
var tCount = teamStats.Count;
var ls = new TeamStats();
var tKeys = teamStats.Keys.ToList();
for (var i = 0; i < tCount; i++)
{
var key = tKeys[i];
if (!playoffs)
{
ls.AddTeamStats(teamStats[key], Span.Season);
teamStats[key].CalcMetrics(oppStats[key]);
oppStats[key].CalcMetrics(teamStats[key]);
}
else
{
ls.AddTeamStats(teamStats[key], Span.Playoffs);
teamStats[key].CalcMetrics(oppStats[key], true);
oppStats[key].CalcMetrics(teamStats[key], true);
}
}
ls.CalcMetrics(ls, playoffs);
double lgAvgPER = 0;
double plLgAvgPER = 0;
double totalMins = 0;
double plTotalMins = 0;
foreach (var playerid in playerStats.Keys.ToList())
{
if (playerStats[playerid].TeamF == -1)
{
continue;
}
var teamid = playerStats[playerid].TeamF;
TeamStats ts;
TeamStats tsopp;
if (!teamsPerPlayer)
{
ts = teamStats[teamid];
tsopp = oppStats[teamid];
}
else
{
ts = teamStats[playerid];
tsopp = oppStats[playerid];
}
playerStats[playerid].CalcMetrics(ts, tsopp, ls, leagueOv, playoffs: playoffs);
if (!playoffs)
{
if (!(Double.IsNaN(playerStats[playerid].Metrics["aPER"]))
&& !(Double.IsInfinity(playerStats[playerid].Metrics["aPER"])))
{
lgAvgPER += playerStats[playerid].Metrics["aPER"] * playerStats[playerid].Totals[PAbbrT.MINS];
totalMins += playerStats[playerid].Totals[PAbbrT.MINS];
}
}
else
{
if (!(Double.IsNaN(playerStats[playerid].PlMetrics["aPER"]))
&& !(Double.IsInfinity(playerStats[playerid].PlMetrics["aPER"])))
{
plLgAvgPER += playerStats[playerid].PlMetrics["aPER"] * playerStats[playerid].PlTotals[PAbbrT.MINS];
plTotalMins += playerStats[playerid].PlTotals[PAbbrT.MINS];
}
}
}
if (!playoffs)
{
lgAvgPER /= totalMins;
}
else
{
plLgAvgPER /= plTotalMins;
}
foreach (var playerid in playerStats.Keys.ToList())
{
if (playerStats[playerid].TeamF == -1)
{
continue;
}
if (!playoffs)
{
playerStats[playerid].calcPER(lgAvgPER);
}
else
{
playerStats[playerid].calcPER(plLgAvgPER, true);
}
}
}
/// <summary>Calculates the Metric Stats for this Player</summary>
/// <param name="ts">The player's team's stats</param>
/// <param name="tsopp">The player's team's opponents' stats</param>
/// <param name="ls">The total league stats</param>
/// <param name="leagueOv">Whether CalcMetrics is being called from the League Overview screen</param>
/// <param name="GmScOnly">Whether to only calculate the GmSc metric.</param>
/// <param name="playoffs">Whether to calculate the metrics based on the playoffs stats.</param>
public void CalcMetrics(
TeamStats ts, TeamStats tsopp, TeamStats ls, bool leagueOv = false, bool GmScOnly = false, bool playoffs = false)
{
var pstats = new double[Totals.Length];
for (var i = 0; i < Totals.Length; i++)
{
if (!playoffs)
{
pstats[i] = Totals[i];
}
else
{
pstats[i] = PlTotals[i];
}
}
var tstats = new double[ts.Totals.Length];
for (var i = 0; i < ts.Totals.Length; i++)
{
if (!playoffs)
{
tstats[i] = ts.Totals[i];
}
else
{
tstats[i] = ts.PlTotals[i];
}
}
var toppstats = new double[tsopp.Totals.Length];
for (var i = 0; i < tsopp.Totals.Length; i++)
{
if (!playoffs)
{
toppstats[i] = tsopp.Totals[i];
}
else
{
toppstats[i] = tsopp.PlTotals[i];
}
}
var lstats = new double[ls.Totals.Length];
for (var i = 0; i < ls.Totals.Length; i++)
{
if (!playoffs)
{
lstats[i] = ls.Totals[i];
}
else
{
lstats[i] = ls.PlTotals[i];
}
}
var pREB = pstats[PAbbrT.OREB] + pstats[PAbbrT.DREB];
var tREB = tstats[TAbbrT.OREB] + tstats[TAbbrT.DREB];
var tempTeamMetricsOwn = !playoffs ? ts.Metrics : ts.PlMetrics;
var tempMetrics = new Dictionary<string, double>(PlayerStatsHelper.MetricsDict);
var gmSc = pstats[PAbbrT.PTS] + 0.4 * pstats[PAbbrT.FGM] - 0.7 * pstats[PAbbrT.FGA]
- 0.4 * (pstats[PAbbrT.FTA] - pstats[PAbbrT.FTM]) + 0.7 * pstats[PAbbrT.OREB] + 0.3 * pstats[PAbbrT.DREB]
+ pstats[PAbbrT.STL] + 0.7 * pstats[PAbbrT.AST] + 0.7 * pstats[PAbbrT.BLK] - 0.4 * pstats[PAbbrT.FOUL]
- pstats[PAbbrT.TOS];
tempMetrics["GmSc"] = gmSc / pstats[PAbbrT.GP];
var gmScE = 36 * (1 / pstats[PAbbrT.MINS]) * gmSc;
tempMetrics["GmScE"] = gmScE;
if (!GmScOnly)
{
#region Metrics that do not require Opponent Stats
var ASTp = pstats[PAbbrT.AST]
/ (((pstats[PAbbrT.MINS] / (tstats[TAbbrT.MINS])) * tstats[TAbbrT.FGM]) - pstats[PAbbrT.FGM]);
tempMetrics["AST%"] = ASTp;
var EFGp = (pstats[PAbbrT.FGM] + 0.5 * pstats[PAbbrT.TPM]) / pstats[PAbbrT.FGA];
tempMetrics["EFG%"] = EFGp;
var tempTeamMetricsOpp = !playoffs ? tsopp.Metrics : tsopp.PlMetrics;
var STLp = (pstats[PAbbrT.STL] * (tstats[TAbbrT.MINS])) / (pstats[PAbbrT.MINS] * tempTeamMetricsOpp["Poss"]);
tempMetrics["STL%"] = STLp;
var TOp = pstats[PAbbrT.TOS] / (pstats[PAbbrT.FGA] + 0.44 * pstats[PAbbrT.FTA] + pstats[PAbbrT.TOS]);
tempMetrics["TO%"] = TOp;
var TSp = pstats[PAbbrT.PTS] / (2 * (pstats[PAbbrT.FGA] + 0.44 * pstats[PAbbrT.FTA]));
tempMetrics["TS%"] = TSp;
var USGp = ((pstats[PAbbrT.FGA] + 0.44 * pstats[PAbbrT.FTA] + pstats[PAbbrT.TOS]) * (tstats[TAbbrT.MINS]))
/ (pstats[PAbbrT.MINS] * (tstats[TAbbrT.FGA] + 0.44 * tstats[TAbbrT.FTA] + tstats[TAbbrT.TOS]));
tempMetrics["USG%"] = USGp;
calculateRates(pstats, ref tempMetrics);
// PER preparations
var lREB = lstats[TAbbrT.OREB] + lstats[TAbbrT.DREB];
var factor = (2 / 3)
- (0.5 * (lstats[TAbbrT.AST] / lstats[TAbbrT.FGM])) / (2 * (lstats[TAbbrT.FGM] / lstats[TAbbrT.FTM]));
var VOP = lstats[TAbbrT.PF]
/ (lstats[TAbbrT.FGA] - lstats[TAbbrT.OREB] + lstats[TAbbrT.TOS] + 0.44 * lstats[TAbbrT.FTA]);
var lDRBp = lstats[TAbbrT.DREB] / lREB;
var uPER = (1 / pstats[PAbbrT.MINS])
* (pstats[PAbbrT.TPM] + (2 / 3) * pstats[PAbbrT.AST]
+ (2 - factor * (tstats[TAbbrT.AST] / tstats[TAbbrT.FGM])) * pstats[PAbbrT.FGM]
+ (pstats[PAbbrT.FTM] * 0.5
* (1 + (1 - (tstats[TAbbrT.AST] / tstats[TAbbrT.FGM]))
+ (2 / 3) * (tstats[TAbbrT.AST] / tstats[TAbbrT.FGM]))) - VOP * pstats[PAbbrT.TOS]
- VOP * lDRBp * (pstats[PAbbrT.FGA] - pstats[PAbbrT.FGM])
- VOP * 0.44 * (0.44 + (0.56 * lDRBp)) * (pstats[PAbbrT.FTA] - pstats[PAbbrT.FTM])
+ VOP * (1 - lDRBp) * (pREB - pstats[PAbbrT.OREB]) + VOP * lDRBp * pstats[PAbbrT.OREB]
+ VOP * pstats[PAbbrT.STL] + VOP * lDRBp * pstats[PAbbrT.BLK]
- pstats[PAbbrT.FOUL]
* ((lstats[TAbbrT.FTM] / lstats[TAbbrT.FOUL]) - 0.44 * (lstats[TAbbrT.FTA] / lstats[TAbbrT.FOUL]) * VOP));
tempMetrics["EFF"] = uPER * 100;
#endregion
#region Metrics that require Opponents stats
if (ts.GetGames() == tsopp.GetGames())
{
var BLKp = (pstats[PAbbrT.BLK] * (tstats[TAbbrT.MINS]))
/ (pstats[PAbbrT.MINS] * (toppstats[TAbbrT.FGA] - toppstats[TAbbrT.TPA]));
var DRBp = (pstats[PAbbrT.DREB] * (tstats[TAbbrT.MINS]))
/ (pstats[PAbbrT.MINS] * (tstats[TAbbrT.DREB] + toppstats[TAbbrT.OREB]));
var ORBp = (pstats[PAbbrT.OREB] * (tstats[TAbbrT.MINS]))
/ (pstats[PAbbrT.MINS] * (tstats[TAbbrT.OREB] + toppstats[TAbbrT.DREB]));
var toppREB = toppstats[TAbbrT.OREB] + toppstats[TAbbrT.DREB];
var REBp = (pREB * (tstats[TAbbrT.MINS])) / (pstats[PAbbrT.MINS] * (tREB + toppREB));
#region Metrics that require league stats
double aPER;
double PPR;
if (ls.Name != "$$Empty")
{
//double paceAdj = ls.temp_metrics["Pace"]/ts.temp_metrics["Pace"];
double estPaceAdj;
if (!playoffs)
{
estPaceAdj = 2 * ls.PerGame[TAbbrPG.PPG] / (ts.PerGame[TAbbrPG.PPG] + tsopp.PerGame[TAbbrPG.PPG]);
}
else
{
estPaceAdj = 2 * ls.PlPerGame[TAbbrPG.PPG] / (ts.PlPerGame[TAbbrPG.PPG] + tsopp.PlPerGame[TAbbrPG.PPG]);
}
aPER = estPaceAdj * uPER;
PPR = 100 * estPaceAdj * (((pstats[PAbbrT.AST] * 2 / 3) - pstats[PAbbrT.TOS]) / pstats[PAbbrT.MINS]);
}
else
{
aPER = Double.NaN;
PPR = Double.NaN;
}
#endregion
tempMetrics["aPER"] = aPER;
tempMetrics["BLK%"] = BLKp;
tempMetrics["DREB%"] = DRBp;
tempMetrics["OREB%"] = ORBp;
tempMetrics["REB%"] = REBp;
tempMetrics["PPR"] = PPR;
#region Offensive Rating
var qAST = ((pstats[PAbbrT.MINS] / (tstats[TAbbrT.MINS] / 5))
* (1.14 * ((tstats[TAbbrT.AST] - pstats[PAbbrT.AST]) / tstats[TAbbrT.FGM])))
+ ((((tstats[TAbbrT.AST] / tstats[TAbbrT.MINS]) * pstats[PAbbrT.MINS] * 5 - pstats[PAbbrT.AST])
/ ((tstats[TAbbrT.FGM] / tstats[TAbbrT.MINS]) * pstats[PAbbrT.MINS] * 5 - pstats[PAbbrT.FGM]))
* (1 - (pstats[PAbbrT.MINS] / (tstats[TAbbrT.MINS] / 5))));
var fgPart = pstats[PAbbrT.FGM]
* (1 - 0.5 * ((pstats[PAbbrT.PTS] - pstats[PAbbrT.FTM]) / (2 * pstats[PAbbrT.FGA])) * qAST);
var astPart = 0.5
* (((tstats[TAbbrT.PF] - tstats[TAbbrT.FTM]) - (pstats[PAbbrT.PTS] - pstats[PAbbrT.FTM]))
/ (2 * (tstats[TAbbrT.FGA] - pstats[PAbbrT.FGA]))) * pstats[PAbbrT.AST];
var pFTp = pstats[PAbbrT.FTM] / pstats[PAbbrT.FTA];
if (double.IsNaN(pFTp))
{
pFTp = 0;
}
var ftPart = (1 - Math.Pow(1 - pFTp, 2)) * 0.4 * pstats[PAbbrT.FTA];
var tFTp = tstats[TAbbrT.FTM] / tstats[TAbbrT.FTA];
if (double.IsNaN(tFTp))
{
tFTp = 0;
}
var teamScPoss = tstats[TAbbrT.FGM] + (1 - Math.Pow(1 - tFTp, 2)) * tstats[TAbbrT.FTA] * 0.4;
var teamOREBPct = tstats[TAbbrT.OREB] / (tstats[TAbbrT.OREB] + toppstats[TAbbrT.DREB]);
var teamPlayPct = teamScPoss / (tstats[TAbbrT.FGA] + tstats[TAbbrT.FTA] * 0.4 + tstats[TAbbrT.TOS]);
var teamOREBWeight = ((1 - teamOREBPct) * teamPlayPct)
/ ((1 - teamOREBPct) * teamPlayPct + teamOREBPct * (1 - teamPlayPct));
var orebPart = pstats[PAbbrT.OREB] * teamOREBWeight * teamPlayPct;
var scPoss = (fgPart + astPart + ftPart) * (1 - (tstats[TAbbrT.OREB] / teamScPoss) * teamOREBWeight * teamPlayPct)
+ orebPart;
var fgxPoss = (pstats[PAbbrT.FGA] - pstats[PAbbrT.FGM]) * (1 - 1.07 * teamOREBPct);
var ftxPoss = Math.Pow(1 - pFTp, 2) * 0.4 * pstats[PAbbrT.FTA];
var totPoss = scPoss + fgxPoss + ftxPoss + pstats[PAbbrT.TOS];
var pprodFGPart = 2 * (pstats[PAbbrT.FGM] + 0.5 * pstats[PAbbrT.TPM])
* (1 - 0.5 * ((pstats[PAbbrT.PTS] - pstats[PAbbrT.FTM]) / (2 * pstats[PAbbrT.FGA])) * qAST);
var pprodASTPart = 2
* ((tstats[TAbbrT.FGM] - pstats[PAbbrT.FGM] + 0.5 * (tstats[TAbbrT.TPM] - pstats[PAbbrT.TPM]))
/ (tstats[TAbbrT.FGM] - pstats[PAbbrT.FGM])) * 0.5
* (((tstats[TAbbrT.PF] - tstats[TAbbrT.FTM]) - (pstats[PAbbrT.PTS] - pstats[PAbbrT.FTM]))
/ (2 * (tstats[TAbbrT.FGA] - pstats[PAbbrT.FGA]))) * pstats[PAbbrT.AST];
var pprodOREBPart = pstats[PAbbrT.OREB] * teamOREBWeight * teamPlayPct
* (tstats[TAbbrT.PF]
/ (tstats[TAbbrT.FGM] + (1 - Math.Pow(1 - tFTp, 2)) * 0.4 * tstats[TAbbrT.FTA]));
var pProd = (pprodFGPart + pprodASTPart + pstats[PAbbrT.FTM])
* (1 - (tstats[TAbbrT.OREB] / teamScPoss) * teamOREBWeight * teamPlayPct) + pprodOREBPart;
var ortg = 100 * (pProd / totPoss);
var floorPct = scPoss / totPoss;
tempMetrics["ORTG"] = ortg;
tempMetrics["Floor%"] = floorPct;
#endregion
#region Defensive Rating
var dorPct = toppstats[TAbbrT.OREB] / (toppstats[TAbbrT.OREB] + tstats[TAbbrT.DREB]);
var dfgPct = toppstats[TAbbrT.FGM] / toppstats[TAbbrT.FGA];
var fmWt = (dfgPct * (1 - dorPct)) / (dfgPct * (1 - dorPct) + (1 - dfgPct) * dorPct);
var stops1 = pstats[PAbbrT.STL] + pstats[PAbbrT.BLK] * fmWt * (1 - 1.07 * dorPct)
+ pstats[PAbbrT.DREB] * (1 - fmWt);
var stops2 = (((toppstats[TAbbrT.FGA] - toppstats[TAbbrT.FGM] - tstats[TAbbrT.BLK]) / tstats[TAbbrT.MINS]) * fmWt
* (1 - 1.07 * dorPct) + ((toppstats[TAbbrT.TOS] - tstats[TAbbrT.STL]) / tstats[TAbbrT.MINS]))
* pstats[PAbbrT.MINS]
+ (pstats[PAbbrT.PTS] / tstats[TAbbrT.PF]) * 0.4 * toppstats[TAbbrT.FTA]
* Math.Pow(1 - (toppstats[TAbbrT.FTM] / toppstats[TAbbrT.FTA]), 2);
var stops = stops1 + stops2;
var stopPct = (stops * toppstats[TAbbrT.MINS]) / (tempTeamMetricsOwn["Poss"] * pstats[PAbbrT.MINS]);
var dPtsPerScPoss = toppstats[TAbbrT.PF]
/ (toppstats[TAbbrT.FGM]
+ (1 - Math.Pow(1 - (toppstats[TAbbrT.FTM] / toppstats[TAbbrT.FTA]), 2))
* toppstats[TAbbrT.FTA] * 0.4);
var drtg = tempTeamMetricsOwn["DRTG"] + 0.2 * (100 * dPtsPerScPoss * (1 - stopPct) - tempTeamMetricsOwn["DRTG"]);
var rtgd = ortg - drtg;
tempMetrics["DRTG"] = drtg;
tempMetrics["RTGd"] = rtgd;
#endregion
}
else
{
tempMetrics["aPER"] = Double.NaN;
tempMetrics["BLK%"] = Double.NaN;
tempMetrics["DREB%"] = Double.NaN;
tempMetrics["OREB%"] = Double.NaN;
tempMetrics["REB%"] = Double.NaN;
tempMetrics["PPR"] = Double.NaN;
tempMetrics["ORTG"] = Double.NaN;
tempMetrics["Floor%"] = Double.NaN;
tempMetrics["DRTG"] = Double.NaN;
tempMetrics["RTGd"] = Double.NaN;
}
#endregion
}
var games = (!playoffs) ? ts.GetGames() : ts.GetPlayoffGames();
var gamesRequired = (int) Math.Ceiling(0.8522 * games);
if (leagueOv)
{
if (pstats[PAbbrT.GP] < gamesRequired)
{
foreach (var name in tempMetrics.Keys.ToList())
{
tempMetrics[name] = Double.NaN;
}
}
}
if (!playoffs)
{
Metrics = new Dictionary<string, double>(tempMetrics);
}
else
{
PlMetrics = new Dictionary<string, double>(tempMetrics);
}
}
/// <summary>
/// Prepares and presents the team stats.
/// </summary>
private void prepareTeamStats()
{
TSRList = new List<TeamStatsRow>();
lssr = new List<TeamStatsRow>();
oppTSRList = new List<TeamStatsRow>();
var ls = new TeamStats(-1, "League");
foreach (int key in _tst.Keys)
{
if (_tst[key].IsHidden)
{
continue;
}
if (!inCurrentFilter(_tst[key]))
{
continue;
}
TSRList.Add(new TeamStatsRow(_tst[key], _pst, _splitTeamStats));
oppTSRList.Add(new TeamStatsRow(_tstOpp[key]));
}
ls = TeamStats.CalculateLeagueAverages(_tst, Span.Season);
lssr.Add(new TeamStatsRow(ls));
TSRList.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
TSRList.Reverse();
oppTSRList.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
//oppTsrList.Reverse();
pl_TSRList = new List<TeamStatsRow>();
pl_Lssr = new List<TeamStatsRow>();
pl_OppTSRList = new List<TeamStatsRow>();
var ls1 = new TeamStats(-1, "League");
foreach (int key1 in _tst.Keys)
{
if (_tst[key1].IsHidden)
{
continue;
}
if (_tst[key1].GetPlayoffGames() == 0)
{
continue;
}
if (!inCurrentFilter(_tst[key1]))
{
continue;
}
pl_TSRList.Add(new TeamStatsRow(_tst[key1], true));
pl_OppTSRList.Add(new TeamStatsRow(_tstOpp[key1], true));
}
ls1 = TeamStats.CalculateLeagueAverages(_tst, Span.Playoffs);
pl_Lssr.Add(new TeamStatsRow(ls1, true));
pl_TSRList.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
pl_TSRList.Reverse();
pl_OppTSRList.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
//pl_oppTsrList.Reverse();
bool isSeason = rbSeason.IsChecked.GetValueOrDefault();
dgvTeamStats.ItemsSource = isSeason ? TSRList : pl_TSRList;
dgvLeagueTeamStats.ItemsSource = isSeason ? lssr : pl_Lssr;
dgvTeamMetricStats.ItemsSource = isSeason ? TSRList : pl_TSRList;
dgvLeagueTeamMetricStats.ItemsSource = isSeason ? lssr : pl_Lssr;
dgvOpponentStats.ItemsSource = isSeason ? oppTSRList : pl_OppTSRList;
dgvLeagueOpponentStats.ItemsSource = isSeason ? lssr : pl_Lssr;
dgvOpponentMetricStats.ItemsSource = isSeason ? oppTSRList : pl_OppTSRList;
dgvLeagueOpponentMetricStats.ItemsSource = isSeason ? lssr : pl_Lssr;
dgvTeamInfo.ItemsSource = TSRList;
}
/// <summary>
/// Adds one or more box scores resulting from an SQLite query to a TeamStats instance.
/// </summary>
/// <param name="res">The result of the query containing the box score records.</param>
/// <param name="ts">The TeamStats instance to be modified.</param>
/// <param name="tsopp">The opposing TeamStats instance to be modified..</param>
public static void AddToTeamStatsFromSQLBoxScores(DataTable res, ref TeamStats ts, ref TeamStats tsopp)
{
foreach (DataRow r in res.Rows)
{
AddToTeamStatsFromSQLBoxScore(r, ref ts, ref tsopp);
}
}
/// <summary>
/// Calculates the metric stats for this team.
/// </summary>
/// <param name="tsopp">The opposing team stats.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the metrics will be calculated based on the team's playoff performances.
/// </param>
public void CalcMetrics(TeamStats tsopp, bool playoffs = false)
{
var tempMetrics = new Dictionary<string, double>();
var tempTotals = new double[Totals.Length];
for (int i = 0; i < Totals.Length; i++)
{
if (!playoffs)
{
tempTotals[i] = Totals[i];
}
else
{
tempTotals[i] = PlTotals[i];
}
}
var toppstats = new double[tsopp.Totals.Length];
for (int i = 0; i < tsopp.Totals.Length; i++)
{
if (!playoffs)
{
toppstats[i] = tsopp.Totals[i];
}
else
{
toppstats[i] = tsopp.PlTotals[i];
}
}
uint games = (!playoffs) ? GetGames() : GetPlayoffGames();
double poss = calcPossMetric(tempTotals, toppstats);
tempMetrics.Add("Poss", poss);
tempMetrics.Add("PossPG", poss/games);
poss = calcPossMetric(toppstats, tempTotals);
Dictionary<string, double> toppmetrics = (!playoffs) ? tsopp.Metrics : tsopp.PlMetrics;
try
{
toppmetrics.Add("Poss", poss);
}
catch
{
Console.WriteLine("Possessions metric couldn't be calculated for team " + ID);
}
double pace = MainWindow.GameLength*((tempMetrics["Poss"] + toppmetrics["Poss"])/(2*(tempTotals[TAbbr.MINS])));
tempMetrics.Add("Pace", pace);
double ortg = (tempTotals[TAbbr.PF]/tempMetrics["Poss"])*100;
tempMetrics.Add("ORTG", ortg);
double drtg = (tempTotals[TAbbr.PA]/tempMetrics["Poss"])*100;
tempMetrics.Add("DRTG", drtg);
double astP = (tempTotals[TAbbr.AST])/
(tempTotals[TAbbr.FGA] + tempTotals[TAbbr.FTA]*0.44 + tempTotals[TAbbr.AST] + tempTotals[TAbbr.TOS]);
tempMetrics.Add("AST%", astP);
double drebP = tempTotals[TAbbr.DREB]/(tempTotals[TAbbr.DREB] + toppstats[TAbbr.OREB]);
tempMetrics.Add("DREB%", drebP);
double efgP = (tempTotals[TAbbr.FGM] + tempTotals[TAbbr.TPM]*0.5)/tempTotals[TAbbr.FGA];
tempMetrics.Add("EFG%", efgP);
double effD = ortg - drtg;
tempMetrics.Add("EFFd", effD);
double tor = tempTotals[TAbbr.TOS]/(tempTotals[TAbbr.FGA] + 0.44*tempTotals[TAbbr.FTA] + tempTotals[TAbbr.TOS]);
tempMetrics.Add("TOR", tor);
double orebP = tempTotals[TAbbr.OREB]/(tempTotals[TAbbr.OREB] + toppstats[TAbbr.DREB]);
tempMetrics.Add("OREB%", orebP);
double ftr = tempTotals[TAbbr.FTM]/tempTotals[TAbbr.FGA];
tempMetrics.Add("FTR", ftr);
float[] tempPerGame = (!playoffs) ? PerGame : PlPerGame;
double pwP = (((tempPerGame[TAbbr.PPG] - tempPerGame[TAbbr.PAPG])*2.7) + ((double) MainWindow.SeasonLength/2))/
MainWindow.SeasonLength;
tempMetrics.Add("PW%", pwP);
double tsP = tempTotals[TAbbr.PF]/(2*(tempTotals[TAbbr.FGA] + 0.44*tempTotals[TAbbr.FTA]));
tempMetrics.Add("TS%", tsP);
double tpr = tempTotals[TAbbr.TPA]/tempTotals[TAbbr.FGA];
tempMetrics.Add("3PR", tpr);
double pythW = MainWindow.SeasonLength*(Math.Pow(tempTotals[TAbbr.PF], 16.5))/
(Math.Pow(tempTotals[TAbbr.PF], 16.5) + Math.Pow(tempTotals[TAbbr.PA], 16.5));
tempMetrics.Add("PythW", pythW);
double pythL = MainWindow.SeasonLength - pythW;
tempMetrics.Add("PythL", pythL);
double gmsc = tempTotals[TAbbr.PF] + 0.4*tempTotals[TAbbr.FGM] - 0.7*tempTotals[TAbbr.FGA] -
0.4*(tempTotals[TAbbr.FTA] - tempTotals[TAbbr.FTM]) + 0.7*tempTotals[TAbbr.OREB] + 0.3*tempTotals[TAbbr.DREB] +
tempTotals[TAbbr.STL] + 0.7*tempTotals[TAbbr.AST] + 0.7*tempTotals[TAbbr.BLK] - 0.4*tempTotals[TAbbr.FOUL] -
tempTotals[TAbbr.TOS];
tempMetrics.Add("GmSc", gmsc/games);
if (!playoffs)
{
Metrics = new Dictionary<string, double>(tempMetrics);
}
else
{
PlMetrics = new Dictionary<string, double>(tempMetrics);
}
}
/// <summary>Updates the Overview tab and loads the appropriate box scores depending on the timeframe.</summary>
private void updateOverviewAndBoxScores()
{
var id = _curTeam;
_curts = _tst[id];
_curtsopp = _tstOpp[id];
_tbsList = new List<TeamBoxScore>();
#region Prepare Team Overview
_bseList = MainWindow.BSHist.Where(bse => bse.BS.Team1ID == _curTeam || bse.BS.Team2ID == _curTeam).ToList();
_bseListSea = _bseList.Where(bse => bse.BS.IsPlayoff == false).ToList();
_bseListPl = _bseList.Where(bse => bse.BS.IsPlayoff).ToList();
foreach (var r in _bseList)
{
var bsr = r.BS.CustomClone();
bsr.PrepareForDisplay(_tst, _curTeam);
_tbsList.Add(bsr);
}
#region Regular Season
var dr = _dtOv.NewRow();
dr["Type"] = "Stats";
dr["Games"] = _curts.GetGames();
dr["Wins (W%)"] = _curts.Record[0].ToString();
dr["Losses (Weff)"] = _curts.Record[1].ToString();
dr["PF"] = _curts.Totals[TAbbrT.PF].ToString();
dr["PA"] = _curts.Totals[TAbbrT.PA].ToString();
dr["PD"] = " ";
dr["FG"] = _curts.Totals[TAbbrT.FGM].ToString() + "-" + _curts.Totals[TAbbrT.FGA].ToString();
dr["3PT"] = _curts.Totals[TAbbrT.TPM].ToString() + "-" + _curts.Totals[TAbbrT.TPA].ToString();
dr["FT"] = _curts.Totals[TAbbrT.FTM].ToString() + "-" + _curts.Totals[TAbbrT.FTA].ToString();
dr["REB"] = (_curts.Totals[TAbbrT.DREB] + _curts.Totals[TAbbrT.OREB]).ToString();
dr["OREB"] = _curts.Totals[TAbbrT.OREB].ToString();
dr["DREB"] = _curts.Totals[TAbbrT.DREB].ToString();
dr["AST"] = _curts.Totals[TAbbrT.AST].ToString();
dr["TO"] = _curts.Totals[TAbbrT.TOS].ToString();
dr["STL"] = _curts.Totals[TAbbrT.STL].ToString();
dr["BLK"] = _curts.Totals[TAbbrT.BLK].ToString();
dr["FOUL"] = _curts.Totals[TAbbrT.FOUL].ToString();
dr["MINS"] = _curts.Totals[TAbbrT.MINS].ToString();
_dtOv.Rows.Add(dr);
dr = _dtOv.NewRow();
_curts.CalcAvg(); // Just to be sure...
dr["Type"] = "Averages";
//dr["Games"] = curts.getGames();
dr["Wins (W%)"] = String.Format("{0:F3}", _curts.PerGame[TAbbrPG.Wp]);
dr["Losses (Weff)"] = String.Format("{0:F2}", _curts.PerGame[TAbbrPG.Weff]);
dr["PF"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.PPG]);
dr["PA"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.PAPG]);
dr["PD"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.PD]);
dr["FG"] = String.Format("{0:F3}", _curts.PerGame[TAbbrPG.FGp]);
dr["FGeff"] = String.Format("{0:F2}", _curts.PerGame[TAbbrPG.FGeff]);
dr["3PT"] = String.Format("{0:F3}", _curts.PerGame[TAbbrPG.TPp]);
dr["3Peff"] = String.Format("{0:F2}", _curts.PerGame[TAbbrPG.TPeff]);
dr["FT"] = String.Format("{0:F3}", _curts.PerGame[TAbbrPG.FTp]);
dr["FTeff"] = String.Format("{0:F2}", _curts.PerGame[TAbbrPG.FTeff]);
dr["REB"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.RPG]);
dr["OREB"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.ORPG]);
dr["DREB"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.DRPG]);
dr["AST"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.APG]);
dr["TO"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.TPG]);
dr["STL"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.SPG]);
dr["BLK"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.BPG]);
dr["FOUL"] = String.Format("{0:F1}", _curts.PerGame[TAbbrPG.FPG]);
_dtOv.Rows.Add(dr);
// Rankings can only be shown based on total stats
// ...for now
var dr2 = _dtOv.NewRow();
dr2["Type"] = "Rankings";
dr2["Wins (W%)"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.Wp];
dr2["Losses (Weff)"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.Weff];
dr2["PF"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.PPG];
dr2["PA"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.PAPG];
dr2["PD"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.PD];
dr2["FG"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.FGp];
dr2["FGeff"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.FGeff];
dr2["3PT"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.TPp];
dr2["3Peff"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.TPeff];
dr2["FT"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.FTp];
dr2["FTeff"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.FTeff];
dr2["REB"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.RPG];
dr2["OREB"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.ORPG];
dr2["DREB"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.DRPG];
dr2["AST"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.APG];
dr2["TO"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.TPG];
dr2["STL"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.SPG];
dr2["BLK"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.BPG];
dr2["FOUL"] = _seasonRankings.RankingsPerGame[id][TAbbrPG.FPG];
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Stats";
dr2["Games"] = _curtsopp.GetGames();
dr2["Wins (W%)"] = _curtsopp.Record[0].ToString();
dr2["Losses (Weff)"] = _curtsopp.Record[1].ToString();
dr2["PF"] = _curtsopp.Totals[TAbbrT.PF].ToString();
dr2["PA"] = _curtsopp.Totals[TAbbrT.PA].ToString();
dr2["PD"] = " ";
dr2["FG"] = _curtsopp.Totals[TAbbrT.FGM].ToString() + "-" + _curtsopp.Totals[TAbbrT.FGA].ToString();
dr2["3PT"] = _curtsopp.Totals[TAbbrT.TPM].ToString() + "-" + _curtsopp.Totals[TAbbrT.TPA].ToString();
dr2["FT"] = _curtsopp.Totals[TAbbrT.FTM].ToString() + "-" + _curtsopp.Totals[TAbbrT.FTA].ToString();
dr2["REB"] = (_curtsopp.Totals[TAbbrT.DREB] + _curtsopp.Totals[TAbbrT.OREB]).ToString();
dr2["OREB"] = _curtsopp.Totals[TAbbrT.OREB].ToString();
dr2["DREB"] = _curtsopp.Totals[TAbbrT.DREB].ToString();
dr2["AST"] = _curtsopp.Totals[TAbbrT.AST].ToString();
dr2["TO"] = _curtsopp.Totals[TAbbrT.TOS].ToString();
dr2["STL"] = _curtsopp.Totals[TAbbrT.STL].ToString();
dr2["BLK"] = _curtsopp.Totals[TAbbrT.BLK].ToString();
dr2["FOUL"] = _curtsopp.Totals[TAbbrT.FOUL].ToString();
dr2["MINS"] = _curtsopp.Totals[TAbbrT.MINS].ToString();
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Avg";
dr2["Wins (W%)"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbrPG.Wp]);
dr2["Losses (Weff)"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbrPG.Weff]);
dr2["PF"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.PPG]);
dr2["PA"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.PAPG]);
dr2["PD"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.PD]);
dr2["FG"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbrPG.FGp]);
dr2["FGeff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbrPG.FGeff]);
dr2["3PT"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbrPG.TPp]);
dr2["3Peff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbrPG.TPeff]);
dr2["FT"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbrPG.FTp]);
dr2["FTeff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbrPG.FTeff]);
dr2["REB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.RPG]);
dr2["OREB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.ORPG]);
dr2["DREB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.DRPG]);
dr2["AST"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.APG]);
dr2["TO"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.TPG]);
dr2["STL"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.SPG]);
dr2["BLK"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.BPG]);
dr2["FOUL"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbrPG.FPG]);
_dtOv.Rows.Add(dr2);
#endregion
#region Playoffs
_dtOv.Rows.Add(_dtOv.NewRow());
dr = _dtOv.NewRow();
dr["Type"] = "Playoffs";
dr["Games"] = _curts.GetPlayoffGames();
dr["Wins (W%)"] = _curts.PlRecord[0].ToString();
dr["Losses (Weff)"] = _curts.PlRecord[1].ToString();
dr["PF"] = _curts.PlTotals[TAbbrT.PF].ToString();
dr["PA"] = _curts.PlTotals[TAbbrT.PA].ToString();
dr["PD"] = " ";
dr["FG"] = _curts.PlTotals[TAbbrT.FGM].ToString() + "-" + _curts.PlTotals[TAbbrT.FGA].ToString();
dr["3PT"] = _curts.PlTotals[TAbbrT.TPM].ToString() + "-" + _curts.PlTotals[TAbbrT.TPA].ToString();
dr["FT"] = _curts.PlTotals[TAbbrT.FTM].ToString() + "-" + _curts.PlTotals[TAbbrT.FTA].ToString();
dr["REB"] = (_curts.PlTotals[TAbbrT.DREB] + _curts.PlTotals[TAbbrT.OREB]).ToString();
dr["OREB"] = _curts.PlTotals[TAbbrT.OREB].ToString();
dr["DREB"] = _curts.PlTotals[TAbbrT.DREB].ToString();
dr["AST"] = _curts.PlTotals[TAbbrT.AST].ToString();
dr["TO"] = _curts.PlTotals[TAbbrT.TOS].ToString();
dr["STL"] = _curts.PlTotals[TAbbrT.STL].ToString();
dr["BLK"] = _curts.PlTotals[TAbbrT.BLK].ToString();
dr["FOUL"] = _curts.PlTotals[TAbbrT.FOUL].ToString();
dr["MINS"] = _curts.PlTotals[TAbbrT.MINS].ToString();
_dtOv.Rows.Add(dr);
dr = _dtOv.NewRow();
dr["Type"] = "Pl Avg";
dr["Wins (W%)"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbrPG.Wp]);
dr["Losses (Weff)"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbrPG.Weff]);
dr["PF"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.PPG]);
dr["PA"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.PAPG]);
dr["PD"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.PD]);
dr["FG"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbrPG.FGp]);
dr["FGeff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbrPG.FGeff]);
dr["3PT"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbrPG.TPp]);
dr["3Peff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbrPG.TPeff]);
dr["FT"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbrPG.FTp]);
dr["FTeff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbrPG.FTeff]);
dr["REB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.RPG]);
dr["OREB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.ORPG]);
dr["DREB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.DRPG]);
dr["AST"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.APG]);
dr["TO"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.TPG]);
dr["STL"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.SPG]);
dr["BLK"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.BPG]);
dr["FOUL"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbrPG.FPG]);
_dtOv.Rows.Add(dr);
dr2 = _dtOv.NewRow();
var count = _tst.Count(z => z.Value.GetPlayoffGames() > 0);
dr2["Type"] = "Pl Rank";
dr2["Wins (W%)"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.Wp];
dr2["Losses (Weff)"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.Weff];
dr2["PF"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.PPG];
dr2["PA"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.PAPG];
dr2["PD"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.PD];
dr2["FG"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.FGp];
dr2["FGeff"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.FGeff];
dr2["3PT"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.TPp];
dr2["3Peff"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.TPeff];
dr2["FT"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.FTp];
dr2["FTeff"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.FTeff];
dr2["REB"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.RPG];
dr2["OREB"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.ORPG];
dr2["DREB"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.DRPG];
dr2["AST"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.APG];
dr2["TO"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.TPG];
dr2["STL"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.SPG];
dr2["BLK"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.BPG];
dr2["FOUL"] = _playoffRankings.RankingsPerGame[id][TAbbrPG.FPG];
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Pl Stats";
dr2["Games"] = _curtsopp.GetPlayoffGames();
dr2["Wins (W%)"] = _curtsopp.PlRecord[0].ToString();
dr2["Losses (Weff)"] = _curtsopp.PlRecord[1].ToString();
dr2["PF"] = _curtsopp.PlTotals[TAbbrT.PF].ToString();
dr2["PA"] = _curtsopp.PlTotals[TAbbrT.PA].ToString();
dr2["PD"] = " ";
dr2["FG"] = _curtsopp.PlTotals[TAbbrT.FGM].ToString() + "-" + _curtsopp.PlTotals[TAbbrT.FGA].ToString();
dr2["3PT"] = _curtsopp.PlTotals[TAbbrT.TPM].ToString() + "-" + _curtsopp.PlTotals[TAbbrT.TPA].ToString();
dr2["FT"] = _curtsopp.PlTotals[TAbbrT.FTM].ToString() + "-" + _curtsopp.PlTotals[TAbbrT.FTA].ToString();
dr2["REB"] = (_curtsopp.PlTotals[TAbbrT.DREB] + _curtsopp.PlTotals[TAbbrT.OREB]).ToString();
dr2["OREB"] = _curtsopp.PlTotals[TAbbrT.OREB].ToString();
dr2["DREB"] = _curtsopp.PlTotals[TAbbrT.DREB].ToString();
dr2["AST"] = _curtsopp.PlTotals[TAbbrT.AST].ToString();
dr2["TO"] = _curtsopp.PlTotals[TAbbrT.TOS].ToString();
dr2["STL"] = _curtsopp.PlTotals[TAbbrT.STL].ToString();
dr2["BLK"] = _curtsopp.PlTotals[TAbbrT.BLK].ToString();
dr2["FOUL"] = _curtsopp.PlTotals[TAbbrT.FOUL].ToString();
dr2["MINS"] = _curtsopp.PlTotals[TAbbrT.MINS].ToString();
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Pl Avg";
dr2["Wins (W%)"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbrPG.Wp]);
dr2["Losses (Weff)"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbrPG.Weff]);
dr2["PF"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.PPG]);
dr2["PA"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.PAPG]);
dr2["PD"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.PD]);
dr2["FG"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbrPG.FGp]);
dr2["FGeff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbrPG.FGeff]);
dr2["3PT"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbrPG.TPp]);
dr2["3Peff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbrPG.TPeff]);
dr2["FT"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbrPG.FTp]);
dr2["FTeff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbrPG.FTeff]);
dr2["REB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.RPG]);
dr2["OREB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.ORPG]);
dr2["DREB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.DRPG]);
dr2["AST"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.APG]);
dr2["TO"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.TPG]);
dr2["STL"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.SPG]);
dr2["BLK"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.BPG]);
dr2["FOUL"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbrPG.FPG]);
_dtOv.Rows.Add(dr2);
#endregion
createViewAndUpdateOverview();
dgvBoxScores.ItemsSource = _tbsList;
#endregion
_curTSR = new TeamStatsRow(_curts);
dgMetrics.ItemsSource = new List<TeamStatsRow> { _curTSR };
updatePBPStats();
}
private void updateGraph()
{
if (cmbGraphStat.SelectedIndex == -1 || cmbTeam.SelectedIndex == -1 || cmbGraphInterval.SelectedIndex == -1)
{
clearGraph();
return;
}
var intervalItem = cmbGraphInterval.SelectedItem.ToString();
var yearlyRows = _dtYea.Rows.Cast<DataRow>().Where(dr => dr[0].ToString().StartsWith("Season")).ToList();
var monthlyStats = MainWindow.SplitTeamStats[_curts.ID].Where(pair => pair.Key.StartsWith("M ")).ToList();
var orderedBSEList = _bseList.OrderBy(bse => bse.BS.GameDate).ToList();
Intervals interval;
int count;
switch (intervalItem)
{
case "Every Game":
interval = Intervals.EveryGame;
count = orderedBSEList.Count;
break;
case "Monthly":
interval = Intervals.Monthly;
count = monthlyStats.Count;
break;
case "Yearly":
interval = Intervals.Yearly;
count = yearlyRows.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:
for (var i = 0; i < count; i++)
{
var bse = orderedBSEList[i];
bse.BS.PrepareForDisplay(_tst, _curts.ID);
var isTeamAway = bse.BS.Team1ID == _curts.ID;
var propToGetFinal = propToGet;
if (propToGet == "PF")
{
propToGetFinal = isTeamAway ? "PTS1" : "PTS2";
}
else if (propToGet == "PA")
{
propToGetFinal = isTeamAway ? "PTS2" : "PTS1";
}
else
{
propToGetFinal += (isTeamAway ? 1 : 2).ToString();
}
var value = bse.BS.GetValue<TeamBoxScore, double>(propToGetFinal);
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:
monthlyStats = monthlyStats.OrderBy(ms => ms.Key).ToList();
if (TeamStatsHelper.TotalsToPerGame.ContainsKey(propToGet))
{
propToGet = TeamStatsHelper.TotalsToPerGame[propToGet];
}
for (var i = 0; i < count; i++)
{
var ts = monthlyStats[i].Value;
ts.CalcMetrics(new TeamStats());
var tsr = new TeamStatsRow(ts);
var value = tsr.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;
case Intervals.Yearly:
if (TeamStatsHelper.TotalsToPerGame.ContainsKey(propToGet))
{
propToGet = TeamStatsHelper.TotalsToPerGame[propToGet];
}
for (var i = 0; i < count; i++)
{
var ts = new TeamStats();
createTeamStatsFromDataRow(ref ts, _dtYea.Rows.Cast<DataRow>().ToList()[i]);
ts.CalcMetrics(new TeamStats());
var tsr = new TeamStatsRow(ts);
var value = tsr.GetValue<TeamStatsRow, 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);
}
if (chart.Primitives.Count > 0 && chart.Primitives.Sum(p => p.Points.Count) > 1)
{
//var average = sum / games;
if (TeamStatsHelper.TotalsToPerGame.ContainsKey(propToGet))
{
propToGet = TeamStatsHelper.TotalsToPerGame[propToGet];
}
double average;
switch (interval)
{
case Intervals.EveryGame:
case Intervals.Monthly:
average = _curTSR.GetValue<double>(propToGet);
break;
case Intervals.Yearly:
var ts = new TeamStats();
createTeamStatsFromDataRow(ref ts, _dtYea.Rows.Cast<DataRow>().ToList().Last());
ts.CalcMetrics(new TeamStats());
var tsr = new TeamStatsRow(ts);
average = tsr.GetValue<double>(propToGet);
break;
default:
throw new ArgumentOutOfRangeException();
}
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();
}
/// <summary>
/// Updates the Overview tab and loads the appropriate box scores depending on the timeframe.
/// </summary>
private void updateOverviewAndBoxScores()
{
int id = _curTeam;
_curts = _tst[id];
_curtsopp = _tstOpp[id];
_bsrList = new List<TeamBoxScore>();
#region Prepare Team Overview
IEnumerable<BoxScoreEntry> boxScoreEntries =
MainWindow.BSHist.Where(bse => bse.BS.Team1ID == _curTeam || bse.BS.Team2ID == _curTeam);
foreach (BoxScoreEntry r in boxScoreEntries)
{
TeamBoxScore bsr = r.BS.DeepClone();
bsr.PrepareForDisplay(_tst, _curTeam);
_bsrList.Add(bsr);
}
#region Regular Season
DataRow dr = _dtOv.NewRow();
dr["Type"] = "Stats";
dr["Games"] = _curts.GetGames();
dr["Wins (W%)"] = _curts.Record[0].ToString();
dr["Losses (Weff)"] = _curts.Record[1].ToString();
dr["PF"] = _curts.Totals[TAbbr.PF].ToString();
dr["PA"] = _curts.Totals[TAbbr.PA].ToString();
dr["PD"] = " ";
dr["FG"] = _curts.Totals[TAbbr.FGM].ToString() + "-" + _curts.Totals[TAbbr.FGA].ToString();
dr["3PT"] = _curts.Totals[TAbbr.TPM].ToString() + "-" + _curts.Totals[TAbbr.TPA].ToString();
dr["FT"] = _curts.Totals[TAbbr.FTM].ToString() + "-" + _curts.Totals[TAbbr.FTA].ToString();
dr["REB"] = (_curts.Totals[TAbbr.DREB] + _curts.Totals[TAbbr.OREB]).ToString();
dr["OREB"] = _curts.Totals[TAbbr.OREB].ToString();
dr["DREB"] = _curts.Totals[TAbbr.DREB].ToString();
dr["AST"] = _curts.Totals[TAbbr.AST].ToString();
dr["TO"] = _curts.Totals[TAbbr.TOS].ToString();
dr["STL"] = _curts.Totals[TAbbr.STL].ToString();
dr["BLK"] = _curts.Totals[TAbbr.BLK].ToString();
dr["FOUL"] = _curts.Totals[TAbbr.FOUL].ToString();
dr["MINS"] = _curts.Totals[TAbbr.MINS].ToString();
_dtOv.Rows.Add(dr);
dr = _dtOv.NewRow();
_curts.CalcAvg(); // Just to be sure...
dr["Type"] = "Averages";
//dr["Games"] = curts.getGames();
dr["Wins (W%)"] = String.Format("{0:F3}", _curts.PerGame[TAbbr.Wp]);
dr["Losses (Weff)"] = String.Format("{0:F2}", _curts.PerGame[TAbbr.Weff]);
dr["PF"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.PPG]);
dr["PA"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.PAPG]);
dr["PD"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.PD]);
dr["FG"] = String.Format("{0:F3}", _curts.PerGame[TAbbr.FGp]);
dr["FGeff"] = String.Format("{0:F2}", _curts.PerGame[TAbbr.FGeff]);
dr["3PT"] = String.Format("{0:F3}", _curts.PerGame[TAbbr.TPp]);
dr["3Peff"] = String.Format("{0:F2}", _curts.PerGame[TAbbr.TPeff]);
dr["FT"] = String.Format("{0:F3}", _curts.PerGame[TAbbr.FTp]);
dr["FTeff"] = String.Format("{0:F2}", _curts.PerGame[TAbbr.FTeff]);
dr["REB"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.RPG]);
dr["OREB"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.ORPG]);
dr["DREB"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.DRPG]);
dr["AST"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.APG]);
dr["TO"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.TPG]);
dr["STL"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.SPG]);
dr["BLK"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.BPG]);
dr["FOUL"] = String.Format("{0:F1}", _curts.PerGame[TAbbr.FPG]);
_dtOv.Rows.Add(dr);
// Rankings can only be shown based on total stats
// ...for now
DataRow dr2;
dr2 = _dtOv.NewRow();
dr2["Type"] = "Rankings";
dr2["Wins (W%)"] = _seasonRankings.RankingsPerGame[id][TAbbr.Wp];
dr2["Losses (Weff)"] = _seasonRankings.RankingsPerGame[id][TAbbr.Weff];
dr2["PF"] = _seasonRankings.RankingsPerGame[id][TAbbr.PPG];
dr2["PA"] = cmbTeam.Items.Count + 1 - _seasonRankings.RankingsPerGame[id][TAbbr.PAPG];
dr2["PD"] = _seasonRankings.RankingsPerGame[id][TAbbr.PD];
dr2["FG"] = _seasonRankings.RankingsPerGame[id][TAbbr.FGp];
dr2["FGeff"] = _seasonRankings.RankingsPerGame[id][TAbbr.FGeff];
dr2["3PT"] = _seasonRankings.RankingsPerGame[id][TAbbr.TPp];
dr2["3Peff"] = _seasonRankings.RankingsPerGame[id][TAbbr.TPeff];
dr2["FT"] = _seasonRankings.RankingsPerGame[id][TAbbr.FTp];
dr2["FTeff"] = _seasonRankings.RankingsPerGame[id][TAbbr.FTeff];
dr2["REB"] = _seasonRankings.RankingsPerGame[id][TAbbr.RPG];
dr2["OREB"] = _seasonRankings.RankingsPerGame[id][TAbbr.ORPG];
dr2["DREB"] = _seasonRankings.RankingsPerGame[id][TAbbr.DRPG];
dr2["AST"] = _seasonRankings.RankingsPerGame[id][TAbbr.APG];
dr2["TO"] = cmbTeam.Items.Count + 1 - _seasonRankings.RankingsPerGame[id][TAbbr.TPG];
dr2["STL"] = _seasonRankings.RankingsPerGame[id][TAbbr.SPG];
dr2["BLK"] = _seasonRankings.RankingsPerGame[id][TAbbr.BPG];
dr2["FOUL"] = cmbTeam.Items.Count + 1 - _seasonRankings.RankingsPerGame[id][TAbbr.FPG];
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Stats";
dr2["Games"] = _curtsopp.GetGames();
dr2["Wins (W%)"] = _curtsopp.Record[0].ToString();
dr2["Losses (Weff)"] = _curtsopp.Record[1].ToString();
dr2["PF"] = _curtsopp.Totals[TAbbr.PF].ToString();
dr2["PA"] = _curtsopp.Totals[TAbbr.PA].ToString();
dr2["PD"] = " ";
dr2["FG"] = _curtsopp.Totals[TAbbr.FGM].ToString() + "-" + _curtsopp.Totals[TAbbr.FGA].ToString();
dr2["3PT"] = _curtsopp.Totals[TAbbr.TPM].ToString() + "-" + _curtsopp.Totals[TAbbr.TPA].ToString();
dr2["FT"] = _curtsopp.Totals[TAbbr.FTM].ToString() + "-" + _curtsopp.Totals[TAbbr.FTA].ToString();
dr2["REB"] = (_curtsopp.Totals[TAbbr.DREB] + _curtsopp.Totals[TAbbr.OREB]).ToString();
dr2["OREB"] = _curtsopp.Totals[TAbbr.OREB].ToString();
dr2["DREB"] = _curtsopp.Totals[TAbbr.DREB].ToString();
dr2["AST"] = _curtsopp.Totals[TAbbr.AST].ToString();
dr2["TO"] = _curtsopp.Totals[TAbbr.TOS].ToString();
dr2["STL"] = _curtsopp.Totals[TAbbr.STL].ToString();
dr2["BLK"] = _curtsopp.Totals[TAbbr.BLK].ToString();
dr2["FOUL"] = _curtsopp.Totals[TAbbr.FOUL].ToString();
dr2["MINS"] = _curtsopp.Totals[TAbbr.MINS].ToString();
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Avg";
dr2["Wins (W%)"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbr.Wp]);
dr2["Losses (Weff)"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbr.Weff]);
dr2["PF"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.PPG]);
dr2["PA"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.PAPG]);
dr2["PD"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.PD]);
dr2["FG"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbr.FGp]);
dr2["FGeff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbr.FGeff]);
dr2["3PT"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbr.TPp]);
dr2["3Peff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbr.TPeff]);
dr2["FT"] = String.Format("{0:F3}", _curtsopp.PerGame[TAbbr.FTp]);
dr2["FTeff"] = String.Format("{0:F2}", _curtsopp.PerGame[TAbbr.FTeff]);
dr2["REB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.RPG]);
dr2["OREB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.ORPG]);
dr2["DREB"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.DRPG]);
dr2["AST"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.APG]);
dr2["TO"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.TPG]);
dr2["STL"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.SPG]);
dr2["BLK"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.BPG]);
dr2["FOUL"] = String.Format("{0:F1}", _curtsopp.PerGame[TAbbr.FPG]);
_dtOv.Rows.Add(dr2);
#endregion
#region Playoffs
_dtOv.Rows.Add(_dtOv.NewRow());
dr = _dtOv.NewRow();
dr["Type"] = "Playoffs";
dr["Games"] = _curts.GetPlayoffGames();
dr["Wins (W%)"] = _curts.PlRecord[0].ToString();
dr["Losses (Weff)"] = _curts.PlRecord[1].ToString();
dr["PF"] = _curts.PlTotals[TAbbr.PF].ToString();
dr["PA"] = _curts.PlTotals[TAbbr.PA].ToString();
dr["PD"] = " ";
dr["FG"] = _curts.PlTotals[TAbbr.FGM].ToString() + "-" + _curts.PlTotals[TAbbr.FGA].ToString();
dr["3PT"] = _curts.PlTotals[TAbbr.TPM].ToString() + "-" + _curts.PlTotals[TAbbr.TPA].ToString();
dr["FT"] = _curts.PlTotals[TAbbr.FTM].ToString() + "-" + _curts.PlTotals[TAbbr.FTA].ToString();
dr["REB"] = (_curts.PlTotals[TAbbr.DREB] + _curts.PlTotals[TAbbr.OREB]).ToString();
dr["OREB"] = _curts.PlTotals[TAbbr.OREB].ToString();
dr["DREB"] = _curts.PlTotals[TAbbr.DREB].ToString();
dr["AST"] = _curts.PlTotals[TAbbr.AST].ToString();
dr["TO"] = _curts.PlTotals[TAbbr.TOS].ToString();
dr["STL"] = _curts.PlTotals[TAbbr.STL].ToString();
dr["BLK"] = _curts.PlTotals[TAbbr.BLK].ToString();
dr["FOUL"] = _curts.PlTotals[TAbbr.FOUL].ToString();
dr["MINS"] = _curts.PlTotals[TAbbr.MINS].ToString();
_dtOv.Rows.Add(dr);
dr = _dtOv.NewRow();
dr["Type"] = "Pl Avg";
dr["Wins (W%)"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbr.Wp]);
dr["Losses (Weff)"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbr.Weff]);
dr["PF"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.PPG]);
dr["PA"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.PAPG]);
dr["PD"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.PD]);
dr["FG"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbr.FGp]);
dr["FGeff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbr.FGeff]);
dr["3PT"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbr.TPp]);
dr["3Peff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbr.TPeff]);
dr["FT"] = String.Format("{0:F3}", _curts.PlPerGame[TAbbr.FTp]);
dr["FTeff"] = String.Format("{0:F2}", _curts.PlPerGame[TAbbr.FTeff]);
dr["REB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.RPG]);
dr["OREB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.ORPG]);
dr["DREB"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.DRPG]);
dr["AST"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.APG]);
dr["TO"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.TPG]);
dr["STL"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.SPG]);
dr["BLK"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.BPG]);
dr["FOUL"] = String.Format("{0:F1}", _curts.PlPerGame[TAbbr.FPG]);
_dtOv.Rows.Add(dr);
dr2 = _dtOv.NewRow();
int count = _tst.Count(z => z.Value.GetPlayoffGames() > 0);
dr2["Type"] = "Pl Rank";
dr2["Wins (W%)"] = _playoffRankings.RankingsPerGame[id][TAbbr.Wp];
dr2["Losses (Weff)"] = _playoffRankings.RankingsPerGame[id][TAbbr.Weff];
dr2["PF"] = _playoffRankings.RankingsPerGame[id][TAbbr.PPG];
dr2["PA"] = count + 1 - _playoffRankings.RankingsPerGame[id][TAbbr.PAPG];
dr2["PD"] = _playoffRankings.RankingsPerGame[id][TAbbr.PD];
dr2["FG"] = _playoffRankings.RankingsPerGame[id][TAbbr.FGp];
dr2["FGeff"] = _playoffRankings.RankingsPerGame[id][TAbbr.FGeff];
dr2["3PT"] = _playoffRankings.RankingsPerGame[id][TAbbr.TPp];
dr2["3Peff"] = _playoffRankings.RankingsPerGame[id][TAbbr.TPeff];
dr2["FT"] = _playoffRankings.RankingsPerGame[id][TAbbr.FTp];
dr2["FTeff"] = _playoffRankings.RankingsPerGame[id][TAbbr.FTeff];
dr2["REB"] = _playoffRankings.RankingsPerGame[id][TAbbr.RPG];
dr2["OREB"] = _playoffRankings.RankingsPerGame[id][TAbbr.ORPG];
dr2["DREB"] = _playoffRankings.RankingsPerGame[id][TAbbr.DRPG];
dr2["AST"] = _playoffRankings.RankingsPerGame[id][TAbbr.APG];
dr2["TO"] = count + 1 - _playoffRankings.RankingsPerGame[id][TAbbr.TPG];
dr2["STL"] = _playoffRankings.RankingsPerGame[id][TAbbr.SPG];
dr2["BLK"] = _playoffRankings.RankingsPerGame[id][TAbbr.BPG];
dr2["FOUL"] = count + 1 - _playoffRankings.RankingsPerGame[id][TAbbr.FPG];
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Pl Stats";
dr2["Games"] = _curtsopp.GetPlayoffGames();
dr2["Wins (W%)"] = _curtsopp.PlRecord[0].ToString();
dr2["Losses (Weff)"] = _curtsopp.PlRecord[1].ToString();
dr2["PF"] = _curtsopp.PlTotals[TAbbr.PF].ToString();
dr2["PA"] = _curtsopp.PlTotals[TAbbr.PA].ToString();
dr2["PD"] = " ";
dr2["FG"] = _curtsopp.PlTotals[TAbbr.FGM].ToString() + "-" + _curtsopp.PlTotals[TAbbr.FGA].ToString();
dr2["3PT"] = _curtsopp.PlTotals[TAbbr.TPM].ToString() + "-" + _curtsopp.PlTotals[TAbbr.TPA].ToString();
dr2["FT"] = _curtsopp.PlTotals[TAbbr.FTM].ToString() + "-" + _curtsopp.PlTotals[TAbbr.FTA].ToString();
dr2["REB"] = (_curtsopp.PlTotals[TAbbr.DREB] + _curtsopp.PlTotals[TAbbr.OREB]).ToString();
dr2["OREB"] = _curtsopp.PlTotals[TAbbr.OREB].ToString();
dr2["DREB"] = _curtsopp.PlTotals[TAbbr.DREB].ToString();
dr2["AST"] = _curtsopp.PlTotals[TAbbr.AST].ToString();
dr2["TO"] = _curtsopp.PlTotals[TAbbr.TOS].ToString();
dr2["STL"] = _curtsopp.PlTotals[TAbbr.STL].ToString();
dr2["BLK"] = _curtsopp.PlTotals[TAbbr.BLK].ToString();
dr2["FOUL"] = _curtsopp.PlTotals[TAbbr.FOUL].ToString();
dr2["MINS"] = _curtsopp.PlTotals[TAbbr.MINS].ToString();
_dtOv.Rows.Add(dr2);
dr2 = _dtOv.NewRow();
dr2["Type"] = "Opp Pl Avg";
dr2["Wins (W%)"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbr.Wp]);
dr2["Losses (Weff)"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbr.Weff]);
dr2["PF"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.PPG]);
dr2["PA"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.PAPG]);
dr2["PD"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.PD]);
dr2["FG"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbr.FGp]);
dr2["FGeff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbr.FGeff]);
dr2["3PT"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbr.TPp]);
dr2["3Peff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbr.TPeff]);
dr2["FT"] = String.Format("{0:F3}", _curtsopp.PlPerGame[TAbbr.FTp]);
dr2["FTeff"] = String.Format("{0:F2}", _curtsopp.PlPerGame[TAbbr.FTeff]);
dr2["REB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.RPG]);
dr2["OREB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.ORPG]);
dr2["DREB"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.DRPG]);
dr2["AST"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.APG]);
dr2["TO"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.TPG]);
dr2["STL"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.SPG]);
dr2["BLK"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.BPG]);
dr2["FOUL"] = String.Format("{0:F1}", _curtsopp.PlPerGame[TAbbr.FPG]);
_dtOv.Rows.Add(dr2);
#endregion
createViewAndUpdateOverview();
dgvBoxScores.ItemsSource = _bsrList;
#endregion
}
/// <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"];
}
/// <summary>Prepares and presents the team stats.</summary>
private void prepareTeamStats()
{
_tsrListSea = new List<TeamStatsRow>();
_lssrSea = new List<TeamStatsRow>();
_oppTSRListSea = new List<TeamStatsRow>();
var ls = new TeamStats(-1, "League");
foreach (var key in _tst.Keys)
{
if (_tst[key].IsHidden)
{
continue;
}
if (!inCurrentFilter(_tst[key]))
{
continue;
}
_tsrListSea.Add(new TeamStatsRow(_tst[key], _pst, _splitTeamStats));
_oppTSRListSea.Add(new TeamStatsRow(_tstOpp[key]));
}
ls = TeamStats.CalculateLeagueAverages(_tst, Span.Season);
_lssrSea.Add(new TeamStatsRow(ls));
_tsrListSea.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
_tsrListSea.Reverse();
_oppTSRListSea.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
//oppTsrList.Reverse();
_tsrListPl = new List<TeamStatsRow>();
_lssrPl = new List<TeamStatsRow>();
_oppTSRListPl = new List<TeamStatsRow>();
var ls1 = new TeamStats(-1, "League");
foreach (var key1 in _tst.Keys)
{
if (_tst[key1].IsHidden)
{
continue;
}
if (_tst[key1].GetPlayoffGames() == 0)
{
continue;
}
if (!inCurrentFilter(_tst[key1]))
{
continue;
}
_tsrListPl.Add(new TeamStatsRow(_tst[key1], true));
_oppTSRListPl.Add(new TeamStatsRow(_tstOpp[key1], true));
}
ls1 = TeamStats.CalculateLeagueAverages(_tst, Span.Playoffs);
_lssrPl.Add(new TeamStatsRow(ls1, true));
_tsrListPl.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
_tsrListPl.Reverse();
_oppTSRListPl.Sort((tmsr1, tmsr2) => tmsr1.EFFd.CompareTo(tmsr2.EFFd));
//pl_oppTsrList.Reverse();
var isSeason = rbSeason.IsChecked.GetValueOrDefault();
dgvTeamStats.ItemsSource = isSeason ? _tsrListSea : _tsrListPl;
dgvLeagueTeamStats.ItemsSource = isSeason ? _lssrSea : _lssrPl;
dgvTeamMetricStats.ItemsSource = isSeason ? _tsrListSea : _tsrListPl;
dgvLeagueTeamMetricStats.ItemsSource = isSeason ? _lssrSea : _lssrPl;
dgvOpponentStats.ItemsSource = isSeason ? _oppTSRListSea : _oppTSRListPl;
dgvLeagueOpponentStats.ItemsSource = isSeason ? _lssrSea : _lssrPl;
dgvOpponentMetricStats.ItemsSource = isSeason ? _oppTSRListSea : _oppTSRListPl;
dgvLeagueOpponentMetricStats.ItemsSource = isSeason ? _lssrSea : _lssrPl;
dgvTeamInfo.ItemsSource = _tsrListSea;
}
/// <summary>Calculates the yearly stats and updates the yearly stats tab.</summary>
private void updateYearlyStats()
{
_dtYea.Clear();
var currentDB = MainWindow.CurrentDB;
_curSeason = MainWindow.CurSeason;
_maxSeason = SQLiteIO.GetMaxSeason(currentDB);
var ts = _tst[_curTeam];
var tsAllSeasons = new TeamStats(-1, "All Seasons");
var tsAllPlayoffs = new TeamStats(-1, "All Playoffs");
var tsAll = new TeamStats(-1, "All Games");
tsAllSeasons.AddTeamStats(ts, Span.Season);
tsAllPlayoffs.AddTeamStats(ts, Span.Playoffs);
tsAll.AddTeamStats(ts, Span.SeasonAndPlayoffsToSeason);
var drcur = _dtYea.NewRow();
var drcurPl = _dtYea.NewRow();
createDataRowFromTeamStats(ts, ref drcur, "Season " + MainWindow.GetSeasonName(_curSeason));
var playedInPlayoffs = false;
if (ts.PlRecord[0] + ts.PlRecord[1] > 0)
{
createDataRowFromTeamStats(ts, ref drcurPl, "Playoffs " + MainWindow.GetSeasonName(_curSeason), true);
playedInPlayoffs = true;
}
//
var qr = string.Format(@"SELECT * FROM PastTeamStats WHERE TeamID = {0} ORDER BY ""SOrder""", ts.ID);
var dt = _db.GetDataTable(qr);
foreach (DataRow dr in dt.Rows)
{
var dr4 = _dtYea.NewRow();
ts = new TeamStats();
if (ParseCell.GetBoolean(dr, "isPlayoff"))
{
SQLiteIO.GetTeamStatsFromDataRow(ref ts, dr, true);
createDataRowFromTeamStats(ts, ref dr4, "Playoffs " + ParseCell.GetString(dr, "SeasonName"), true);
tsAllPlayoffs.AddTeamStats(ts, Span.Playoffs);
tsAll.AddTeamStats(ts, Span.Playoffs);
}
else
{
SQLiteIO.GetTeamStatsFromDataRow(ref ts, dr, false);
createDataRowFromTeamStats(ts, ref dr4, "Season " + ParseCell.GetString(dr, "SeasonName"), false);
tsAllSeasons.AddTeamStats(ts, Span.Season);
tsAll.AddTeamStats(ts, Span.Season);
}
_dtYea.Rows.Add(dr4);
}
//
for (var j = 1; j <= _maxSeason; j++)
{
if (j != _curSeason)
{
TeamStats tsopp;
SQLiteIO.GetTeamStatsFromDatabase(MainWindow.CurrentDB, _curTeam, j, out ts, out tsopp);
var dr3 = _dtYea.NewRow();
var dr3Pl = _dtYea.NewRow();
createDataRowFromTeamStats(ts, ref dr3, "Season " + MainWindow.GetSeasonName(j));
_dtYea.Rows.Add(dr3);
if (ts.PlRecord[0] + ts.PlRecord[1] > 0)
{
createDataRowFromTeamStats(ts, ref dr3Pl, "Playoffs " + MainWindow.GetSeasonName(j), true);
_dtYea.Rows.Add(dr3Pl);
}
tsAllSeasons.AddTeamStats(ts, Span.Season);
tsAllPlayoffs.AddTeamStats(ts, Span.Playoffs);
tsAll.AddTeamStats(ts, Span.SeasonAndPlayoffsToSeason);
}
else
{
_dtYea.Rows.Add(drcur);
if (playedInPlayoffs)
{
_dtYea.Rows.Add(drcurPl);
}
}
}
_dtYea.Rows.Add(_dtYea.NewRow());
drcur = _dtYea.NewRow();
createDataRowFromTeamStats(tsAllSeasons, ref drcur, "All Seasons");
_dtYea.Rows.Add(drcur);
drcur = _dtYea.NewRow();
createDataRowFromTeamStats(tsAllPlayoffs, ref drcur, "All Playoffs");
_dtYea.Rows.Add(drcur);
_dtYea.Rows.Add(_dtYea.NewRow());
drcur = _dtYea.NewRow();
createDataRowFromTeamStats(tsAll, ref drcur, "All Games");
_dtYea.Rows.Add(drcur);
var dvYea = new DataView(_dtYea) { AllowNew = false, AllowEdit = false };
dgvYearly.DataContext = dvYea;
}
private void calculate2KRatings(bool playoffs = false)
{
string gpPctSetting = MainWindow.RatingsGPPctSetting;
double gpPCTreq = MainWindow.RatingsGPPctRequired;
string mpgSetting = MainWindow.RatingsMPGSetting;
float MPGreq = MainWindow.RatingsMPGRequired;
uint pGP = GP;
var team = new TeamStats();
uint tGP = 0;
try
{
team = MainWindow.TST.Single(ts => ts.Value.ID == TeamF).Value;
tGP = playoffs ? team.GetPlayoffGames() : team.GetGames();
}
catch (InvalidOperationException)
{
gpPctSetting = "-1";
}
if ((gpPctSetting != "-1" && (double) (pGP*100)/tGP < gpPCTreq) || (mpgSetting != "-1" && MPG < MPGreq))
{
reRFT = -1;
reRPass = -1;
reRBlock = -1;
reRSteal = -1;
reROffRbd = -1;
reRDefRbd = -1;
reTShotTnd = -1;
reTDrawFoul = -1;
reTTouch = -1;
reTCommitFl = -1;
return;
}
try
{
reRFT = Convert.ToInt32(100*FTp);
if (reRFT > 99)
{
reRFT = 99;
}
}
catch
{
reRFT = -1;
}
try
{
double ASTp100 = ASTp*100;
reRPass = Convert.ToInt32(31.1901795687457 + 1.36501096444891*ASTp100 + 4.34894327991171/(-0.702541953738967 - ASTp100));
if (reRPass > 99)
{
reRPass = 99;
}
}
catch
{
reRPass = -1;
}
try
{
double BLKp100 = BLKp*100;
reRBlock =
Convert.ToInt32(25.76 + 17.03*BLKp100 + 0.8376*Math.Pow(BLKp100, 3) - 3.195*Math.Pow(BLKp100, 2) -
0.07319*Math.Pow(BLKp100, 4));
if (reRBlock > 99)
{
reRBlock = 99;
}
}
catch
{
reRBlock = -1;
}
try
{
double STLp100 = STLp*100;
reRSteal = Convert.ToInt32(29.92 + 14.57*STLp100 - 0.1509*Math.Pow(STLp100, 2));
if (reRSteal > 99)
{
reRSteal = 99;
}
}
catch
{
reRSteal = -1;
}
try
{
double OREBp100 = OREBp*100;
reROffRbd =
Convert.ToInt32(24.67 + 3.864*OREBp100 + 0.3523*Math.Pow(OREBp100, 2) + 0.0007358*Math.Pow(OREBp100, 4) -
0.02796*Math.Pow(OREBp100, 3));
if (reROffRbd > 99)
{
reROffRbd = 99;
}
}
catch
{
reROffRbd = -1;
}
try
{
double DREBp100 = DREBp*100;
reRDefRbd = Convert.ToInt32(25 + 2.5*DREBp100);
if (reRDefRbd > 99)
{
reRDefRbd = 99;
}
}
catch
{
reRDefRbd = -1;
}
try
{
reTShotTnd = Convert.ToInt32(2 + 4*FGAPG);
if (reTShotTnd > 90)
{
reTShotTnd = 90;
}
}
catch
{
reTShotTnd = -1;
}
try
{
reTDrawFoul = Convert.ToInt32(FTAR*10);
if (reTDrawFoul > 99)
{
reTDrawFoul = 99;
}
}
catch
{
reTDrawFoul = -1;
}
try
{
double FGAR = (double) FGA/MINS*36;
int touchTotal = Convert.ToInt32(FGAR + FTAR + TOR + ASTR);
reTTouch = Convert.ToInt32(3.141*Math.Pow(touchTotal, 2)/(1.178 + touchTotal));
if (reTTouch > 99)
{
reTTouch = 99;
}
}
catch
{
reTTouch = -1;
}
try
{
reTCommitFl = Convert.ToInt32((double) FOUL/MINS*36*10);
if (reTCommitFl > 99)
{
reTCommitFl = 99;
}
}
catch
{
reTCommitFl = -1;
}
}
private void prepareHeadToHeadTab(out List<PlayerStatsRow> teamPMSRList, out List<PlayerStatsRow> oppPMSRList)
{
var iown = _curTeam;
var iopp = _curOpp;
var dtHTHBS = new DataTable();
dtHTHBS.Columns.Add("Date");
dtHTHBS.Columns.Add("Home-Away");
dtHTHBS.Columns.Add("Result");
dtHTHBS.Columns.Add("Score");
dtHTHBS.Columns.Add("GameID");
var ts = new TeamStats(_curTeam);
var tsopp = new TeamStats(_curOpp);
_db = new SQLiteDatabase(MainWindow.CurrentDB);
if (_dtHTH.Rows.Count > 1)
{
_dtHTH.Rows.RemoveAt(_dtHTH.Rows.Count - 1);
}
var bsHist = MainWindow.BSHist;
var bseList =
bsHist.Where(
bse =>
(bse.BS.Team1ID == _curTeam && bse.BS.Team2ID == _curOpp)
|| (bse.BS.Team1ID == _curOpp && bse.BS.Team2ID == _curTeam)).ToList();
if (rbHTHStatsAnyone.IsChecked.GetValueOrDefault())
{
ts = _tst[iown];
ts.CalcAvg();
tsopp = _tst[iopp];
tsopp.CalcAvg();
}
else
{
foreach (var bse in bseList)
{
TeamStats.AddTeamStatsFromBoxScore(bse.BS, ref ts, ref tsopp, true);
}
}
//ts.CalcMetrics(tsopp);
//tsopp.CalcMetrics(ts);
var ls = new TeamStats();
ls.AddTeamStats(ts, Span.SeasonAndPlayoffsToSeason);
ls.AddTeamStats(tsopp, Span.SeasonAndPlayoffsToSeason);
var keys = _pst.Keys.ToList();
teamPMSRList = new List<PlayerStatsRow>();
oppPMSRList = new List<PlayerStatsRow>();
foreach (var key in keys)
{
if (_pst[key].TeamF == ts.ID)
{
teamPMSRList.Add(new PlayerStatsRow(_pst[key]));
}
else if (_pst[key].TeamF == tsopp.ID)
{
oppPMSRList.Add(new PlayerStatsRow(_pst[key]));
}
}
foreach (var bse in bseList)
{
int t1PTS = bse.BS.PTS1;
int t2PTS = bse.BS.PTS2;
var bsr = dtHTHBS.NewRow();
bsr["Date"] = bse.BS.GameDate.ToString().Split(' ')[0];
if (bse.BS.Team1ID.Equals(_curTeam))
{
bsr["Home-Away"] = "Away";
if (t1PTS > t2PTS)
{
bsr["Result"] = "W";
}
else
{
bsr["Result"] = "L";
}
}
else
{
bsr["Home-Away"] = "Home";
if (t2PTS > t1PTS)
{
bsr["Result"] = "W";
}
else
{
bsr["Result"] = "L";
}
}
bsr["Score"] = bse.BS.PTS1 + "-" + bse.BS.PTS2;
bsr["GameID"] = bse.BS.ID.ToString();
dtHTHBS.Rows.Add(bsr);
}
_dtHTH.Clear();
var dr = _dtHTH.NewRow();
createDataRowFromTeamStats(ts, ref dr, "Averages");
_dtHTH.Rows.Add(dr);
dr = _dtHTH.NewRow();
createDataRowFromTeamStats(tsopp, ref dr, "Opp Avg");
_dtHTH.Rows.Add(dr);
dr = _dtHTH.NewRow();
createDataRowFromTeamStats(ts, ref dr, "Playoffs", true);
_dtHTH.Rows.Add(dr);
dr = _dtHTH.NewRow();
createDataRowFromTeamStats(tsopp, ref dr, "Opp Pl Avg", true);
_dtHTH.Rows.Add(dr);
_dvHTH = new DataView(_dtHTH) { AllowNew = false, AllowEdit = false };
dgvHTHStats.DataContext = _dvHTH;
var dvHTHBS = new DataView(dtHTHBS) { AllowNew = false, AllowEdit = false };
dgvHTHBoxScores.DataContext = dvHTHBS;
}
/// <summary>Adds one or more box scores resulting from an SQLite query to a TeamStats instance.</summary>
/// <param name="res">The result of the query containing the box score records.</param>
/// <param name="ts">The TeamStats instance to be modified.</param>
/// <param name="tsopp">The opposing TeamStats instance to be modified..</param>
private static void addToTeamStatsFromSQLBoxScores(DataTable res, ref TeamStats ts, ref TeamStats tsopp)
{
foreach (DataRow r in res.Rows)
{
addToTeamStatsFromSQLBoxScore(r, ref ts, ref tsopp);
}
}
/// <summary>Creates a data row from a TeamStats instance.</summary>
/// <param name="ts">The TeamStats instance.</param>
/// <param name="dr">The data row to be edited.</param>
/// <param name="title">The title for the row's Type or Name column.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the row will present the team's playoff stats; otherwise, the regular season's.
/// </param>
private static void createDataRowFromTeamStats(TeamStats ts, ref DataRow dr, string title, bool playoffs = false)
{
try
{
dr["Type"] = title;
}
catch
{
dr["Name"] = title;
}
float[] PerGame;
if (!playoffs)
{
PerGame = ts.PerGame;
dr["Games"] = ts.GetGames();
dr["Wins"] = ts.Record[0].ToString();
dr["Losses"] = ts.Record[1].ToString();
}
else
{
PerGame = ts.PlPerGame;
dr["Games"] = ts.GetPlayoffGames();
dr["Wins"] = ts.PlRecord[0].ToString();
dr["Losses"] = ts.PlRecord[1].ToString();
}
dr["W%"] = String.Format("{0:F3}", PerGame[TAbbrPG.Wp]);
dr["Weff"] = String.Format("{0:F2}", PerGame[TAbbrPG.Weff]);
dr["PF"] = String.Format("{0:F1}", PerGame[TAbbrPG.PPG]);
dr["PA"] = String.Format("{0:F1}", PerGame[TAbbrPG.PAPG]);
dr["PD"] = String.Format("{0:F1}", PerGame[TAbbrPG.PD]);
dr["FG"] = String.Format("{0:F3}", PerGame[TAbbrPG.FGp]);
dr["FGeff"] = String.Format("{0:F2}", PerGame[TAbbrPG.FGeff]);
dr["3PT"] = String.Format("{0:F3}", PerGame[TAbbrPG.TPp]);
dr["3Peff"] = String.Format("{0:F2}", PerGame[TAbbrPG.TPeff]);
dr["FT"] = String.Format("{0:F3}", PerGame[TAbbrPG.FTp]);
dr["FTeff"] = String.Format("{0:F2}", PerGame[TAbbrPG.FTeff]);
dr["REB"] = String.Format("{0:F1}", PerGame[TAbbrPG.RPG]);
dr["OREB"] = String.Format("{0:F1}", PerGame[TAbbrPG.ORPG]);
dr["DREB"] = String.Format("{0:F1}", PerGame[TAbbrPG.DRPG]);
dr["AST"] = String.Format("{0:F1}", PerGame[TAbbrPG.APG]);
dr["TO"] = String.Format("{0:F1}", PerGame[TAbbrPG.TPG]);
dr["STL"] = String.Format("{0:F1}", PerGame[TAbbrPG.SPG]);
dr["BLK"] = String.Format("{0:F1}", PerGame[TAbbrPG.BPG]);
dr["FOUL"] = String.Format("{0:F1}", PerGame[TAbbrPG.FPG]);
dr["MINS"] = String.Format("{0:F1}", PerGame[TAbbrPG.MPG]);
}
/// <summary>Calculates the league PerGame.</summary>
/// <param name="tst">The team stats dictionary.</param>
/// <param name="statRange">The stat range.</param>
/// <returns></returns>
public static TeamStats CalculateLeagueAverages(Dictionary<int, TeamStats> tst, Span statRange)
{
var ls = new TeamStats(-1, "League");
var teamCount = countTeams(tst, statRange);
for (var i = 0; i < tst.Count; i++)
{
ls.AddTeamStats(tst[i], statRange);
}
ls.CalcMetrics(ls, (statRange == Span.Playoffs));
ls.Record[0] /= teamCount;
ls.Record[1] /= teamCount;
ls.PlRecord[0] /= teamCount;
ls.PlRecord[1] /= teamCount;
ls.PerGame[TAbbrPG.Weff] /= teamCount;
ls.PlPerGame[TAbbrPG.Weff] /= teamCount;
return ls;
}
private static void createTeamStatsFromDataRow(ref TeamStats ts, DataRow dr, bool playoffs = false)
{
var Totals = !playoffs ? ts.Totals : ts.PlTotals;
var PerGame = !playoffs ? ts.PerGame : ts.PlPerGame;
var Record = !playoffs ? ts.Record : ts.PlRecord;
Record[0] = ParseCell.GetUInt16(dr, "Wins");
Record[1] = ParseCell.GetUInt16(dr, "Losses");
PerGame[TAbbrPG.Wp] = ParseCell.GetFloat(dr, "W%");
PerGame[TAbbrPG.Weff] = ParseCell.GetFloat(dr, "Weff");
PerGame[TAbbrPG.PPG] = ParseCell.GetFloat(dr, "PF");
PerGame[TAbbrPG.PAPG] = ParseCell.GetFloat(dr, "PA");
PerGame[TAbbrPG.PD] = ParseCell.GetFloat(dr, "PD");
PerGame[TAbbrPG.FGp] = ParseCell.GetFloat(dr, "FG");
PerGame[TAbbrPG.FGeff] = ParseCell.GetFloat(dr, "FGeff");
PerGame[TAbbrPG.TPp] = ParseCell.GetFloat(dr, "3PT");
PerGame[TAbbrPG.TPeff] = ParseCell.GetFloat(dr, "3Peff");
PerGame[TAbbrPG.FTp] = ParseCell.GetFloat(dr, "FT");
PerGame[TAbbrPG.FTeff] = ParseCell.GetFloat(dr, "FTeff");
PerGame[TAbbrPG.RPG] = ParseCell.GetFloat(dr, "REB");
PerGame[TAbbrPG.ORPG] = ParseCell.GetFloat(dr, "OREB");
PerGame[TAbbrPG.DRPG] = ParseCell.GetFloat(dr, "DREB");
PerGame[TAbbrPG.APG] = ParseCell.GetFloat(dr, "AST");
PerGame[TAbbrPG.TPG] = ParseCell.GetFloat(dr, "TO");
PerGame[TAbbrPG.SPG] = ParseCell.GetFloat(dr, "STL");
PerGame[TAbbrPG.BPG] = ParseCell.GetFloat(dr, "BLK");
PerGame[TAbbrPG.FPG] = ParseCell.GetFloat(dr, "FOUL");
PerGame[TAbbrPG.MPG] = ParseCell.GetFloat(dr, "MINS");
var games = Record[0] + Record[1];
Totals[TAbbrT.PF] = Convert.ToUInt32(PerGame[TAbbrPG.PPG] * games);
Totals[TAbbrT.PA] = Convert.ToUInt32(PerGame[TAbbrPG.PAPG] * games);
Totals[TAbbrT.FGM] = Convert.ToUInt32((PerGame[TAbbrPG.FGeff] / PerGame[TAbbrPG.FGp]) * games);
Totals[TAbbrT.FGA] = Convert.ToUInt32(Totals[TAbbrT.FGM] / PerGame[TAbbrPG.FGp]);
Totals[TAbbrT.TPM] = Convert.ToUInt32((PerGame[TAbbrPG.TPeff] / PerGame[TAbbrPG.TPp]) * games);
Totals[TAbbrT.TPA] = Convert.ToUInt32(Totals[TAbbrT.TPM] / PerGame[TAbbrPG.TPp]);
Totals[TAbbrT.FTM] = Convert.ToUInt32((PerGame[TAbbrPG.FTeff] / PerGame[TAbbrPG.FTp]) * games);
Totals[TAbbrT.FTA] = Convert.ToUInt32(Totals[TAbbrT.FTM] / PerGame[TAbbrPG.FTp]);
Totals[TAbbrT.DREB] = Convert.ToUInt32(PerGame[TAbbrPG.DRPG] * games);
Totals[TAbbrT.OREB] = Convert.ToUInt32(PerGame[TAbbrPG.ORPG] * games);
Totals[TAbbrT.AST] = Convert.ToUInt32(PerGame[TAbbrPG.APG] * games);
Totals[TAbbrT.TOS] = Convert.ToUInt32(PerGame[TAbbrPG.TPG] * games);
Totals[TAbbrT.STL] = Convert.ToUInt32(PerGame[TAbbrPG.SPG] * games);
Totals[TAbbrT.BLK] = Convert.ToUInt32(PerGame[TAbbrPG.BPG] * games);
Totals[TAbbrT.FOUL] = Convert.ToUInt32(PerGame[TAbbrPG.FPG] * games);
Totals[TAbbrT.MINS] = Convert.ToUInt32(PerGame[TAbbrPG.MPG] * games);
}
/// <summary>Calculates the metric stats for this team.</summary>
/// <param name="tsopp">The opposing team stats.</param>
/// <param name="playoffs">
/// if set to <c>true</c>, the metrics will be calculated based on the team's playoff performances.
/// </param>
public void CalcMetrics(TeamStats tsopp, bool playoffs = false)
{
var tempMetricsOwn = new Dictionary<string, double>();
var tempTotalsOwn = new double[Totals.Length];
for (var i = 0; i < Totals.Length; i++)
{
if (!playoffs)
{
tempTotalsOwn[i] = Totals[i];
}
else
{
tempTotalsOwn[i] = PlTotals[i];
}
}
var tempTotalsOpp = new double[tsopp.Totals.Length];
if ((!playoffs && (GetGames() != tsopp.GetGames())) || (playoffs && (GetPlayoffGames() != tsopp.GetPlayoffGames())))
{
for (var i = 0; i < tsopp.Totals.Length; i++)
{
tempTotalsOpp[i] = double.NaN;
}
}
else
{
for (var i = 0; i < tsopp.Totals.Length; i++)
{
if (!playoffs)
{
tempTotalsOpp[i] = tsopp.Totals[i];
}
else
{
tempTotalsOpp[i] = tsopp.PlTotals[i];
}
}
}
var games = (!playoffs) ? GetGames() : GetPlayoffGames();
var poss = calcPossMetric(tempTotalsOwn, tempTotalsOpp);
tempMetricsOwn.Add("Poss", poss);
tempMetricsOwn.Add("PossPG", poss / games);
var tempMetricsOpp = (!playoffs) ? tsopp.Metrics : tsopp.PlMetrics;
try
{
tempMetricsOpp.Add("Poss", poss);
}
catch (ArgumentException)
{
tempMetricsOpp["Poss"] = poss;
}
catch
{
Console.WriteLine("Possessions metric couldn't be calculated for team " + ID);
}
var pace = MainWindow.GameLength * ((tempMetricsOwn["Poss"] + tempMetricsOpp["Poss"]) / (2 * (tempTotalsOwn[TAbbrT.MINS])));
tempMetricsOwn.Add("Pace", pace);
var ortg = (tempTotalsOwn[TAbbrT.PF] / tempMetricsOwn["Poss"]) * 100;
tempMetricsOwn.Add("ORTG", ortg);
var drtg = (tempTotalsOwn[TAbbrT.PA] / tempMetricsOwn["Poss"]) * 100;
tempMetricsOwn.Add("DRTG", drtg);
var astP = (tempTotalsOwn[TAbbrT.AST])
/ (tempTotalsOwn[TAbbrT.FGA] + tempTotalsOwn[TAbbrT.FTA] * 0.44 + tempTotalsOwn[TAbbrT.AST]
+ tempTotalsOwn[TAbbrT.TOS]);
tempMetricsOwn.Add("AST%", astP);
var drebP = tempTotalsOwn[TAbbrT.DREB] / (tempTotalsOwn[TAbbrT.DREB] + tempTotalsOpp[TAbbrT.OREB]);
tempMetricsOwn.Add("DREB%", drebP);
var efgP = (tempTotalsOwn[TAbbrT.FGM] + tempTotalsOwn[TAbbrT.TPM] * 0.5) / tempTotalsOwn[TAbbrT.FGA];
tempMetricsOwn.Add("EFG%", efgP);
var effD = ortg - drtg;
tempMetricsOwn.Add("EFFd", effD);
var tor = tempTotalsOwn[TAbbrT.TOS]
/ (tempTotalsOwn[TAbbrT.FGA] + 0.44 * tempTotalsOwn[TAbbrT.FTA] + tempTotalsOwn[TAbbrT.TOS]);
tempMetricsOwn.Add("TOR", tor);
var orebP = tempTotalsOwn[TAbbrT.OREB] / (tempTotalsOwn[TAbbrT.OREB] + tempTotalsOpp[TAbbrT.DREB]);
tempMetricsOwn.Add("OREB%", orebP);
var ftr = tempTotalsOwn[TAbbrT.FTM] / tempTotalsOwn[TAbbrT.FGA];
tempMetricsOwn.Add("FTR", ftr);
var tempPerGame = (!playoffs) ? PerGame : PlPerGame;
var pwP = (((tempPerGame[TAbbrPG.PPG] - tempPerGame[TAbbrPG.PAPG]) * 2.7) + ((double) MainWindow.SeasonLength / 2))
/ MainWindow.SeasonLength;
tempMetricsOwn.Add("PW%", pwP);
var tsP = tempTotalsOwn[TAbbrT.PF] / (2 * (tempTotalsOwn[TAbbrT.FGA] + 0.44 * tempTotalsOwn[TAbbrT.FTA]));
tempMetricsOwn.Add("TS%", tsP);
var tpr = tempTotalsOwn[TAbbrT.TPA] / tempTotalsOwn[TAbbrT.FGA];
tempMetricsOwn.Add("3PR", tpr);
var pythW = MainWindow.SeasonLength * (Math.Pow(tempTotalsOwn[TAbbrT.PF], 16.5))
/ (Math.Pow(tempTotalsOwn[TAbbrT.PF], 16.5) + Math.Pow(tempTotalsOwn[TAbbrT.PA], 16.5));
tempMetricsOwn.Add("PythW", pythW);
var pythL = MainWindow.SeasonLength - pythW;
tempMetricsOwn.Add("PythL", pythL);
var gmsc = tempTotalsOwn[TAbbrT.PF] + 0.4 * tempTotalsOwn[TAbbrT.FGM] - 0.7 * tempTotalsOwn[TAbbrT.FGA]
- 0.4 * (tempTotalsOwn[TAbbrT.FTA] - tempTotalsOwn[TAbbrT.FTM]) + 0.7 * tempTotalsOwn[TAbbrT.OREB]
+ 0.3 * tempTotalsOwn[TAbbrT.DREB] + tempTotalsOwn[TAbbrT.STL] + 0.7 * tempTotalsOwn[TAbbrT.AST]
+ 0.7 * tempTotalsOwn[TAbbrT.BLK] - 0.4 * tempTotalsOwn[TAbbrT.FOUL] - tempTotalsOwn[TAbbrT.TOS];
tempMetricsOwn.Add("GmSc", gmsc / games);
if (!playoffs)
{
Metrics = new Dictionary<string, double>(tempMetricsOwn);
}
else
{
PlMetrics = new Dictionary<string, double>(tempMetricsOwn);
}
}
/// <summary>Handles the Click event of the btnAdd control. Allows the user to add teams or players the database.</summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">
/// The <see cref="RoutedEventArgs" /> instance containing the event data.
/// </param>
private async void btnAdd_Click(object sender, RoutedEventArgs e)
{
if (String.IsNullOrEmpty(CurrentDB))
{
return;
}
if (Tf.IsBetween)
{
IsEnabled = false;
Tf = new Timeframe(CurSeason);
await UpdateAllData();
IsEnabled = true;
}
AddInfo = "";
var aw = new AddWindow(ref PST);
aw.ShowDialog();
if (!String.IsNullOrEmpty(AddInfo))
{
if (AddInfo != "$$NST Players Added")
{
var parts = Tools.SplitLinesToArray(AddInfo);
var newTeams = parts.Where(s => !String.IsNullOrWhiteSpace(s)).ToList();
var oldlen = TST.Count;
if (SQLiteIO.IsTSTEmpty())
{
oldlen = 0;
}
for (var i = 0; i < newTeams.Count; i++)
{
if (TST.Count(pair => pair.Value.Name == newTeams[i]) == 1)
{
MessageBox.Show(
"There's a team with the name " + newTeams[i] + " already in the database so it won't be added again.");
continue;
}
var newid = oldlen + i;
TST[newid] = new TeamStats(newid, newTeams[i]);
TSTOpp[newid] = new TeamStats(newid, newTeams[i]);
}
await saveAndReloadSeason();
UpdateStatus("Teams were added, database saved.");
}
else
{
await saveAndReloadSeason();
UpdateStatus("Players were added, database saved.");
}
}
}
