private void UpdatePlayerListView(IEnumerable <IPlayer> players)
{
this.lvAnalysis.BeginUpdate();
this.lvAnalysis.Items.Clear();
foreach (IPlayer player in players)
{
ListViewItem item = new ListViewItem(player.Name);
foreach (IStatExtractor extractor in LeagueConstants.For(this.league.FantasyLeague).ScoringStatExtractors.Union(LeagueConstants.For(this.league.FantasyLeague).SupportingStatExtractors))
{
IStatValue value = extractor.Extract(player);
if (value != null)
{
item.SubItems.Add(value.Value.ToString());
}
else
{
item.SubItems.Add(string.Empty);
}
}
this.lvAnalysis.Items.Add(item);
}
this.lvAnalysis.EndUpdate();
}
public int GetPercentile(IStatExtractor statExtractor, IEnumerable <IPlayer> playerSet, IPlayer selectedPlayer)
{
List <Tuple <IStatValue, IPlayer> > playersWithStats = new List <Tuple <IStatValue, IPlayer> >();
foreach (IPlayer player in playerSet)
{
IStatValue statValue = statExtractor.Extract(player);
if (statValue != null && !float.IsInfinity(statValue.Value))
{
playersWithStats.Add(new Tuple <IStatValue, IPlayer>(statValue, player));
}
}
if (statExtractor.MoreIsBetter)
{
playersWithStats.Sort((Tuple <IStatValue, IPlayer> x, Tuple <IStatValue, IPlayer> y) => y.Item1.Value.CompareTo(x.Item1.Value));
}
else
{
playersWithStats.Sort((Tuple <IStatValue, IPlayer> x, Tuple <IStatValue, IPlayer> y) => x.Item1.Value.CompareTo(y.Item1.Value));
}
for (int i = 0; i < playersWithStats.Count; i++)
{
if (playersWithStats[i].Item2 == selectedPlayer)
{
return(100 - ((i * 100) / playersWithStats.Count));
}
}
return(-1);
}
public IEnumerable <PlayerAnalysis> Analyze(IEnumerable <IPlayer> players)
{
int total = 0;
List <PlayerAnalysis> analyses = new List <PlayerAnalysis>();
foreach (IPlayer player in players)
{
IStatValue value = this.extractor.Extract(player);
if (value != null)
{
analyses.Add(new PlayerAnalysis(player, this.extractor.StatName, value.Value));
total += value.CountableValue;
}
}
if (this.extractor.MoreIsBetter)
{
analyses.Sort((x, y) => y.RawValue.CompareTo(x.RawValue));
}
else
{
analyses.Sort((x, y) => x.RawValue.CompareTo(y.RawValue));
}
for (int i = 0; i < analyses.Count; i++)
{
analyses[i].Rank = i + 1;
analyses[i].Percentage = analyses[i].RawValue / (float)total;
yield return(analyses[i]);
}
}
public static void UpdateStatsPlayerList(League league, ListView lv, Func <IPlayer, bool> playerPassesFilter)
{
LeagueConstants lc = LeagueConstants.For(league.FantasyLeague);
lv.BeginUpdate();
foreach (IPlayer player in league.AllPlayers)
{
if (playerPassesFilter(player))
{
ListViewItem item = new ListViewItem(player.Name);
item.SubItems.Add(player.Status);
foreach (IStatExtractor extractor in lc.ScoringStatExtractors)
{
IStatValue value = extractor.Extract(player);
if (value != null)
{
item.SubItems.Add(value.Value.ToString());
}
else
{
item.SubItems.Add(string.Empty);
}
}
lv.Items.Add(item);
}
}
lv.EndUpdate();
}
public PlayerGroupAnalysis Analyze(string groupDescription, IStatExtractor statExtractor, IEnumerable <IPlayer> playerSet, IPlayer selectedPlayer, Func <IPlayer, Brush> playerToBrush)
{
List <Tuple <IStatValue, IPlayer> > playersWithStats = new List <Tuple <IStatValue, IPlayer> >();
float barMin = float.MaxValue;
float barMax = float.MinValue;
foreach (IPlayer player in playerSet)
{
IStatValue statValue = statExtractor.Extract(player);
if (statValue != null && !float.IsInfinity(statValue.Value))
{
playersWithStats.Add(new Tuple <IStatValue, IPlayer>(statValue, player));
barMin = Math.Min(barMin, statValue.Value);
barMax = Math.Max(barMax, statValue.Value);
}
}
if (statExtractor.MoreIsBetter)
{
playersWithStats.Sort((Tuple <IStatValue, IPlayer> x, Tuple <IStatValue, IPlayer> y) => y.Item1.Value.CompareTo(x.Item1.Value));
}
else
{
playersWithStats.Sort((Tuple <IStatValue, IPlayer> x, Tuple <IStatValue, IPlayer> y) => x.Item1.Value.CompareTo(y.Item1.Value));
}
const int barWidth = 3;
const int imgHeight = 480;
int playerPercentile = -1;
float playerStatValue = float.MinValue;
int imgWidth = barWidth * playersWithStats.Count;
Bitmap graph = new Bitmap(imgWidth, imgHeight);
using (Graphics g = Graphics.FromImage(graph))
{
for (int i = 0; i < playersWithStats.Count; i++)
{
float barHeightPercent = playersWithStats[i].Item1.Value / barMax;
int barHeight = (int)(barHeightPercent * imgHeight);
Rectangle rect = new Rectangle(i * barWidth, imgHeight - barHeight, barWidth, barHeight);
Brush brush = playerToBrush(playersWithStats[i].Item2);
if (playersWithStats[i].Item2 == selectedPlayer)
{
playerPercentile = 100 - ((i * 100) / playersWithStats.Count);
playerStatValue = playersWithStats[i].Item1.Value;
}
g.FillRectangle(brush, rect);
}
}
return(new PlayerGroupAnalysis(groupDescription, statExtractor.StatName, graph, playersWithStats.Count, barMin, barMax, selectedPlayer, playerStatValue, playerPercentile));
}
public static List <Tuple <IStatValue, int> > ExtractAnalysisDataSet(IEnumerable <int> playerList, IStatExtractor extractor, Root root, Constants.StatSource statSource)
{
List <Tuple <IStatValue, int> > playersWithStats = new List <Tuple <IStatValue, int> >();
foreach (int player in playerList)
{
IStatValue statValue = extractor.Extract(root, player, statSource);
if (statValue != null && !float.IsInfinity(statValue.Value))
{
playersWithStats.Add(new Tuple <IStatValue, int>(statValue, player));
}
}
if (extractor.MoreIsBetter)
{
playersWithStats.Sort((Tuple <IStatValue, int> x, Tuple <IStatValue, int> y) => y.Item1.Value.CompareTo(x.Item1.Value));
}
else
{
playersWithStats.Sort((Tuple <IStatValue, int> x, Tuple <IStatValue, int> y) => x.Item1.Value.CompareTo(y.Item1.Value));
}
return(playersWithStats);
}
private void OnStatValueChange(IStatValue iStatValue)
{
statValue.text = iStatValue.StatValue.ToString();
}
private void OnHealthValueChange(IStatValue iStatValue)
{
healthBar.SetActiveFill(healthVital.StatValueCurrent, healthVital.StatValue);
}
public static void AssignStatsAndPoints(List <IRoster> teams, IReadOnlyList <IStatExtractor> extractors)
{
foreach (IRoster team in teams)
{
foreach (IStatExtractor extractor in extractors)
{
List <IStatValue> statValues = new List <IStatValue>();
foreach (IPlayer p in team.Players)
{
IStatValue value = extractor.Extract(p);
if (value != null)
{
statValues.Add(value);
}
}
if (statValues.Count > 0)
{
IStatValue agg = extractor.Aggregate(statValues);
team.Stats[extractor.StatName] = agg.Value;
}
}
}
foreach (IStatExtractor extractor in extractors)
{
if (extractor.MoreIsBetter)
{
teams.Sort((x, y) => Compare(x, y, extractor.StatName));
}
else
{
teams.Sort((x, y) => Compare(y, x, extractor.StatName));
}
for (int i = 0; i < teams.Count;)
{
if (teams[i].Stats.ContainsKey(extractor.StatName))
{
int countOfEqual = 1;
int totalPoints = teams.Count - i;
while (i + countOfEqual < teams.Count &&
teams[i + countOfEqual - 1].Stats.ContainsKey(extractor.StatName) &&
teams[i + countOfEqual].Stats.ContainsKey(extractor.StatName) &&
teams[i + countOfEqual - 1].Stats[extractor.StatName] == teams[i + countOfEqual].Stats[extractor.StatName])
{
totalPoints += teams.Count - (i + countOfEqual);
countOfEqual++;
}
float pointsPer = (float)totalPoints / countOfEqual;
for (int k = 0; k < countOfEqual; k++)
{
teams[i + k].Points[extractor.StatName] = pointsPer;
}
i += countOfEqual;
}
else
{
teams[i].Points[extractor.StatName] = 0;
i++;
}
}
}
}
public TeamStatCenter(League league, TeamAnalysis team)
{
InitializeComponent();
this.Text = string.Format("Team Stat Center: {0}", team.Team.Name);
LeagueConstants lc = LeagueConstants.For(league.FantasyLeague);
this.lv.BeginUpdate();
int columnWidth = lv.Width / (lc.ScoringStatExtractors.Count + 2);
lv.Columns.Add("Player Name", columnWidth);
lv.Columns.Add("Player Status", columnWidth);
foreach (IStatExtractor extractor in lc.ScoringStatExtractors)
{
ColumnHeader column = new ColumnHeader();
column.Text = extractor.StatName;
column.Width = columnWidth;
lv.Columns.Add(column);
}
Dictionary <string, int> statToPlayerCount = new Dictionary <string, int>();
foreach (IPlayer player in team.Players)
{
ListViewItem item = new ListViewItem(player.Name);
item.SubItems.Add(player.Status);
foreach (IStatExtractor extractor in lc.ScoringStatExtractors)
{
IStatValue value = extractor.Extract(player);
if (value != null)
{
item.SubItems.Add(value.Value.ToString());
if (!statToPlayerCount.ContainsKey(extractor.StatName))
{
statToPlayerCount[extractor.StatName] = 1;
}
else
{
statToPlayerCount[extractor.StatName]++;
}
}
else
{
item.SubItems.Add(string.Empty);
}
}
this.lv.Items.Add(item);
}
ListViewItem total = new ListViewItem("Totals");
ListViewItem average = new ListViewItem("Average");
total.SubItems.Add(string.Empty); // player status
average.SubItems.Add(string.Empty); // player status
foreach (IStatExtractor extractor in lc.ScoringStatExtractors)
{
float value;
if (team.Stats.TryGetValue(extractor.StatName, out value))
{
total.SubItems.Add(value.ToString());
int count;
if (statToPlayerCount.TryGetValue(extractor.StatName, out count))
{
average.SubItems.Add((value / (float)count).ToString());
}
else
{
average.SubItems.Add(string.Empty);
}
}
else
{
total.SubItems.Add(string.Empty);
average.SubItems.Add(string.Empty);
}
}
this.lv.Items.Add(total);
this.lv.Items.Add(average);
this.lv.EndUpdate();
}
private void OnManaValueChange(IStatValue iStatValue)
{
manaBar.SetActiveFill(manaVital.StatValueCurrent, manaVital.StatValue);
}
private void OnEnergyValueChange(IStatValue iStatValue)
{
energyBar.SetActiveFill(energyVital.StatValueCurrent, energyVital.StatValue);
}
/// <summary>
/// Called whenever the Health stat's value is changed
/// </summary>
private void OnHealthValueChange(IStatValue iStatValue)
{
Debug.LogFormat("Health value has changed to {0}", iStatValue.StatValue);
}
/// <summary>
/// Listens to the attached StatLinker's Linked Stat and Updates
/// the StatLinkerValue if a stat linker value changes
/// </summary>
private void OnLinkedStatValueChange(IStatValue iStatValue)
{
UpdateLinkerValue();
}
public AllPlayersStatCenter(League league)
{
InitializeComponent();
LeagueConstants lc = LeagueConstants.For(league.FantasyLeague);
this.lv.BeginUpdate();
int columnWidth = lv.Width / (lc.ScoringStatExtractors.Count + lc.SupportingStatExtractors.Count + 4);
lv.Columns.Add("Player Name", columnWidth);
lv.Columns.Add("Fantasy Team", columnWidth);
foreach (IStatExtractor extractor in lc.ScoringStatExtractors.Union(lc.SupportingStatExtractors))
{
ColumnHeader column = new ColumnHeader();
column.Text = extractor.StatName;
column.Width = columnWidth;
if (!extractor.MoreIsBetter)
{
column.Tag = "asc";
}
lv.Columns.Add(column);
}
lv.Columns.Add("Average Percentile (Batter)", columnWidth);
lv.Columns.Add("Average Percentile (Pitcher)", columnWidth);
Dictionary <string, int> statToPlayerCount = new Dictionary <string, int>();
PercentilePlayerGroupAnalyzer analyzer = new PercentilePlayerGroupAnalyzer();
foreach (IPlayer player in league.AllPlayers)
{
ListViewItem item = new ListViewItem(player.Name);
item.SubItems.Add(player.FantasyTeam);
int percentile = 0;
int statcount = 0;
foreach (IStatExtractor extractor in lc.ScoringStatExtractors.Union(lc.SupportingStatExtractors))
{
IStatValue value = extractor.Extract(player);
if (value != null)
{
IEnumerable <IPlayer> players = league.Batters;
if (!player.IsBatter)
{
players = league.Pitchers;
}
percentile += analyzer.GetPercentile(extractor, players, player);
statcount++;
item.SubItems.Add(value.Value.ToString());
if (!statToPlayerCount.ContainsKey(extractor.StatName))
{
statToPlayerCount[extractor.StatName] = 1;
}
else
{
statToPlayerCount[extractor.StatName]++;
}
}
else
{
item.SubItems.Add(string.Empty);
}
}
if (player.IsBatter)
{
item.SubItems.Add((percentile / statcount).ToString());
item.SubItems.Add(string.Empty);
}
else
{
item.SubItems.Add(string.Empty);
item.SubItems.Add((percentile / statcount).ToString());
}
this.lv.Items.Add(item);
}
this.lv.EndUpdate();
}
