public void StorePrediction(string method, NFLGame game, NFLResult result)
{
// Validate prediction
if ( !result.IsValid() )
Utility.Announce( "Invalid prediction - " + game.GameName() );
// See if we have this prediction already
var ds = Utility.TflWs.GetPrediction(method, game.Season, game.Week, game.GameCode);
if (ds.Tables[0].Rows.Count == 1)
// if yes just update
Utility.TflWs.UpdatePrediction(
method, game.Season, game.Week, game.GameCode, result.HomeScore, result.AwayScore,
result.HomeTDp, result.HomeTDr, result.HomeTDd, result.HomeTDs, result.HomeFg,
result.AwayTDp, result.AwayTDr, result.AwayTDd, result.AwayTDs, result.AwayFg,
result.HomeYDp, result.HomeYDr, result.AwayYDp, result.AwayYDr
);
else
// otherwise insert
Utility.TflWs.InsertPrediction(
method, game.Season, game.Week, game.GameCode, result.HomeScore, result.AwayScore,
result.HomeTDp, result.HomeTDr, result.HomeTDd, result.HomeTDs, result.HomeFg,
result.AwayTDp, result.AwayTDr, result.AwayTDd, result.AwayTDs, result.AwayFg,
result.HomeYDp, result.HomeYDr, result.AwayYDp, result.AwayYDr
);
}
public YahooProjectedPointsMessage Calculate( NFLPlayer p, NFLGame g )
{
if ( yahooPipeline == null ) InitialiseThePipeLine();
var msg = new YahooProjectedPointsMessage { Player = p };
if (g.IsBye()) return msg;
msg.Player.Points = 0.0M;
msg.Game = g;
if (yahooPipeline != null) yahooPipeline.Execute( msg );
return msg;
}
private decimal CalculateFpts(NflTeam team, string theWeek, DataSet gameDs)
{
// Process Stats and Scores for the week
// save the calculations
var game = new NFLGame(gameDs.Tables[0].Rows[0]);
List <NFLPlayer> playerList = new List <NFLPlayer>();
if (game.IsAway(team.TeamCode))
{
playerList = game.LoadAllFantasyAwayPlayers(null, PositionCategory);
}
else
{
playerList = game.LoadAllFantasyHomePlayers(null, PositionCategory);
}
var pts = 0.0M;
var week = new NFLWeek(Season, theWeek);
pts = TallyPts(playerList, week, team.TeamCode);
return(pts);
}
public void LoadGameList()
{
Announce(string.Format("LoadGameList: Loading Teams Week {0}", Week));
_sched = Utility.TflWs.GetGames(Int32.Parse(Season), WeekNo);
if (_sched != null)
{
_gameList = new ArrayList();
var dt = _sched.Tables[0];
foreach (DataRow dr in dt.Rows)
{
var gameCode = $"{Season}:{dr[ "WEEK" ]}-{dr[ "GAMENO" ]}";
Announce(string.Format("LoadGameList: getting Game:{0}", gameCode));
var g = new NFLGame(dr);
_gameList.Add(g);
}
}
else
{
Announce(string.Format("LoadGameList: No Sched"));
}
}
public NFLResult PredictGame(NFLGame game, IStorePredictions persistor, DateTime predictionDate)
{
const int avgScore = 21;
var homeRating = RatingsService.GetNibbleRatingFor(game.HomeNflTeam, predictionDate);
var awayRating = RatingsService.GetNibbleRatingFor(game.AwayNflTeam, predictionDate);
var homeOff = homeRating.Offence;
var homeDef = homeRating.Defence;
var awayOff = awayRating.Offence;
var awayDef = awayRating.Defence;
var homeScore = avgScore + ((homeOff + awayDef) / 2) + 3; // 3pts home field advantage
var awayScore = avgScore + ((awayOff + homeDef) / 2);
homeScore = Utility.PickAScore(homeScore);
awayScore = Utility.PickAScore(awayScore);
if (homeScore == awayScore)
{
homeScore++; // no ties
}
var res = new NFLResult(game.HomeTeam, homeScore, game.AwayTeam, awayScore);
//TODO: Nibble predictor does not predict Tdp or Tdr
if (AuditTrail)
{
AuditPrediction(game, awayDef, awayOff, homeOff, res, homeDef);
if (StorePrediction)
{
StorePredictedResult(game, res);
}
}
return(res);
}
public string RecordMetrics(NFLPlayer player, NFLGame game)
{
var gameKey = game.GameKey();
var pgm = Dao.Get(player.PlayerCode, gameKey);
if (pgm.GameKey != null)
{
pgm.TDp = player.CurrentGameMetrics.TDp;
pgm.TDr = player.CurrentGameMetrics.TDr;
pgm.TDc = player.CurrentGameMetrics.TDc;
pgm.YDp = player.CurrentGameMetrics.YDp;
pgm.YDr = player.CurrentGameMetrics.YDr;
pgm.YDc = player.CurrentGameMetrics.YDc;
pgm.FG = player.CurrentGameMetrics.FG;
pgm.Pat = player.CurrentGameMetrics.Pat;
Dao.Save(pgm);
return(string.Format("Game:{0} Player:{1} metrics:{2}", game.GameName(), player.PlayerName, pgm));
}
else
{
return(string.Format("Failed to find pgm for {0}:{1}", game.GameName(), player.PlayerName));
}
}
public string ActualOutput(NFLGame g, NFLPlayer p)
{
if (!g.Played(addDay: false))
{
return("____");
}
Console.WriteLine(g.ScoreOut());
if (g.GameWeek == null)
{
g.GameWeek = new NFLWeek(g.Season, g.Week);
}
var scorer = new YahooScorer(g.GameWeek)
{
UseProjections = false
};
var nScore = scorer.RatePlayer(
p,
g.GameWeek,
takeCache: false);
return($" {nScore,2:#0} ");
}
private void LoadTeam(NflTeam team, string teamCode)
{
var ep = new EpMetric();
var metricsHt = new Hashtable();
var dg = _tflWs.GetAllGames(teamCode, Season);
var games = dg.Tables["sched"];
foreach (DataRow drg in games.Rows)
{
var g = new NFLGame(drg);
if (!g.IsRecent())
{
continue;
}
if (!g.MetricsCalculated)
{
g.TallyMetrics(String.Empty);
}
var hashCode = string.Format("{0}{1}{2}", teamCode, g.Season, g.Week);
if (g.IsHome(teamCode))
{
ep.HomeTeam = teamCode;
ep.OffTDp = g.HomeTDp;
ep.OffTDr = g.HomeTDr;
ep.OffSakAllowed = g.HomeSaKa;
ep.DefTDp = g.AwayTDp;
ep.DefTDr = g.AwayTDr;
ep.DefSak = g.AwaySaKa;
ep.HomePasses = g.HomePasses;
ep.HomeRuns = g.HomeRuns;
}
else
{
ep.AwayTeam = g.AwayTeam;
ep.OffTDp = g.AwayTDp;
ep.OffTDr = g.AwayTDr;
ep.OffSakAllowed = g.AwaySaKa;
ep.DefTDp = g.HomeTDp;
ep.DefTDr = g.HomeTDr;
ep.DefSak = g.HomeSaKa;
ep.AwayPasses = g.AwayPasses;
ep.AwayRuns = g.AwayRuns;
}
if (DoBreakdowns)
{
AddBreakdown(teamCode, ep, g);
}
if (ep.Total() <= 0)
{
continue;
}
ep.WeekSeed = Utility.WeekSeed(g.Season, g.Week);
if (!metricsHt.ContainsKey(hashCode))
{
metricsHt.Add(hashCode, ep);
}
}
team.SetMetrics(metricsHt);
#if DEBUG
//Utility.PrintIndexAndKeysAndValues( metricsHt );
#endif
}
private void WriteCountLine(DataTable dt, string stat)
{
var dr = dt.NewRow();
dr["STAT"] = stat;
var tot = 0;
foreach (var week in Season.RegularWeeks)
{
var weekNo = string.Format("WK{0}", week.Week);
var actuals = GetActuals(Season.Year, week.Week);
var nInWeek = 0;
var predTab = actuals.Tables["sched"];
foreach (DataRow row in predTab.Rows)
{
var g = new NFLGame(row);
#if DEBUG
Utility.Announce(g.ScoreOut());
#endif
if (g.TotalTds() == 0 || ForceRefresh)
{
g.RefreshTotals();
}
g.TallyMetrics(string.Empty);
switch (stat)
{
case "TDr":
nInWeek += g.HomeTDr + g.AwayTDr;
break;
case "TDp":
nInWeek += g.HomeTDp + g.AwayTDp;
break;
case "TDd":
nInWeek += g.HomeTDd + g.AwayTDd;
break;
case "TDs":
nInWeek += g.HomeTDs + g.AwayTDs;
break;
case "FG":
nInWeek += g.HomeFg + g.AwayFg;
break;
case "YDp":
nInWeek += g.HomeYDp + g.AwayYDp;
break;
case "YDr":
nInWeek += g.HomeYDr + g.AwayYDr;
break;
default:
break;
}
}
if (nInWeek > 0)
{
tot += nInWeek;
dr[weekNo] = string.Format("{0}", nInWeek);
}
}
dr["TOT"] = tot;
dt.Rows.Add(dr);
}
private FptsAllowed CalculateFptsAllowed(
NflTeam team,
string theWeek,
DataSet gameDs)
{
// Process Stats and Scores for the week
// save the calculations
var ftpsAllowed = new FptsAllowed(team.TeamCode);
var game = new NFLGame(gameDs.Tables[0].Rows[0]);
List <NFLPlayer> playerList = new List <NFLPlayer>();
if (game.IsAway(team.TeamCode))
{
playerList = game.LoadAllFantasyHomePlayers(
(DateTime?)game.GameDate,
String.Empty);
}
else
{
playerList = game.LoadAllFantasyAwayPlayers(
( DateTime? )game.GameDate,
String.Empty);
}
var week = new NFLWeek(Season, theWeek);
var scorer = new YahooXmlScorer(week);
foreach (var p in playerList)
{
var plyrPts = scorer.RatePlayer(p, week);
if (p.IsQuarterback())
{
ftpsAllowed.ToQbs += plyrPts;
AddBreakdownLine(team, theWeek, p, plyrPts, "QB");
}
else if (p.IsRb())
{
ftpsAllowed.ToRbs += plyrPts;
AddBreakdownLine(team, theWeek, p, plyrPts, "RB");
}
else if (p.IsWideout())
{
ftpsAllowed.ToWrs += plyrPts;
AddBreakdownLine(team, theWeek, p, plyrPts, "WR");
}
else if (p.IsTe())
{
ftpsAllowed.ToTes += plyrPts;
AddBreakdownLine(team, theWeek, p, plyrPts, "TE");
}
else if (p.IsKicker())
{
ftpsAllowed.ToPks += plyrPts;
AddBreakdownLine(team, theWeek, p, plyrPts, "PK");
}
}
return(ftpsAllowed);
}
public bool Contains(NFLGame game)
{
//TODO: implement
return(true);
}
public void StorePrediction(string method, NFLGame game, NFLResult result)
{
}
private void SummariseGame(NFLGame game)
{
Game = game;
Game.LoadLineups(); // sourcing data from PGMETRIC and LINEUP
Game.LoadPgms();
}
private string DomeBit( NFLGame g, NFLPlayer p )
{
var bit = " ";
if (p.IsKicker() )
{
if ( g.IsDomeGame() )
bit = "+";
}
return bit;
}
static private bool TestTeam(NFLGame g)
{
const string testTeam = "BR";
return((g.HomeTeam == testTeam) || (g.AwayTeam == testTeam));
}
private DataTable BuildTable()
{
var dt = new DataTable();
var cols = dt.Columns;
cols.Add("SLOT", typeof(String));
cols.Add("PLAYER", typeof(String));
cols.Add("TEAM", typeof(String));
cols.Add("FTEAM", typeof(String));
cols.Add("POS", typeof(String));
cols.Add("PTS", typeof(Int16));
cols.Add("UNIT", typeof(String));
cols.Add("ROLE", typeof(String));
cols.Add("GAME", typeof(String));
cols.Add("OPPRATE", typeof(String));
cols.Add("SPREAD", typeof(Decimal));
cols.Add("TOTAL", typeof(Decimal));
cols.Add("BOOKIE", typeof(String));
cols.Add("ACTUAL", typeof(Int16));
PgmList = PgmDao.GetWeek(Season, Week);
var week = Scorer.Week;
foreach (var pgm in PgmList)
{
var p = new NFLPlayer(pgm.PlayerId);
if (!string.IsNullOrEmpty(TeamFilter))
{
if (p.TeamCode != TeamFilter)
{
continue;
}
}
if (!string.IsNullOrEmpty(CategoryFilter))
{
if (p.PlayerCat != CategoryFilter)
{
continue;
}
}
p.LoadOwner(League);
var dr = dt.NewRow();
var game = new NFLGame(pgm.GameKey);
p.LoadProjections(pgm);
var opponent = p.CurrTeam.OpponentFor(Season, Int32.Parse(Week));
// player actually available
dr["PLAYER"] = p.Url(p.PlayerName, forceReport: false);
dr["TEAM"] = p.CurrTeam.TeamCode;
dr["FTEAM"] = p.Owner;
dr["ROLE"] = p.PlayerRole;
dr["POS"] = p.PlayerPos;
dr["PTS"] = Scorer.RatePlayer(p, week);
dr["UNIT"] = game.ProjectionLink();
dr["GAME"] = string.Format("{0} {1} {2}",
game.GameDay(), game.Hour, game.OpponentOut(p.CurrTeam.TeamCode));
dr["SPREAD"] = game.GetSpread();
dr["TOTAL"] = game.Total;
game.CalculateSpreadResult();
dr["BOOKIE"] = game.BookieTip.PredictedScore();
if (opponent != null)
{
dr["OPPRATE"] = opponent.Ratings;
}
//if ( game.Played() )
// dr[ "ACTUAL" ] = ActualPoints( p );
dt.Rows.Add(dr);
}
dt.DefaultView.Sort = "PTS DESC";
return(dt);
}
public string PlayerPiece(
NFLPlayer player,
NFLGame game,
YahooCalculator calculator,
bool bLinks = true,
List <NFLPlayer> runners = null)
{
var nextOppTeam = player.NextOpponentTeam(
game);
var plusMatchup = PlusMatchup(
player,
nextOppTeam,
player.CurrTeam);
var matchupLink = nextOppTeam.DefensiveUnitMatchUp(
player.PlayerCat,
plusMatchup,
bLinks);
var owners = player.LoadAllOwners();
calculator.Calculate(
player,
game);
var namePart = bLinks
? RoleLink(player)
: $"{player.PlayerNameTo(11)}";
if (player.PlayerCat.Equals(
Constants.K_KICKER_CAT))
{
AddPickup(
player,
game,
" ",
DomeBit(game, player));
return(string.Format(" {0,-11} {1} {2,2:#0}{3} {4}",
namePart,
owners,
player.Points,
DomeBit(game, player),
ActualOutput(
game: game,
player: player,
runners: null)));
}
AddPickup(
player,
game,
matchupLink,
DomeBit(game, player));
return(string.Format("{6}{0,-11}{7} {3} {1} {2,2:#0}{5} {4}",
namePart,
matchupLink, // defensiveRating,
player.Points,
owners,
ActualOutput(
game: game,
player: player,
runners: runners),
DomeBit(game, player),
ReturnerBit(player),
ShortYardageBit(player)));
}
public void StorePrediction( string method, NFLGame game, NFLResult result )
{
}
// rank points are used to sort players
public decimal RankPoints(NFLPlayer player, NFLGame game, NflTeam opponent)
{
decimal points = 0;
#region short cut
if (RankMaster.Contains(player.PlayerCode))
{
var rankedPlayer = ( NFLPlayer )RankMaster[player.PlayerCode];
return(rankedPlayer.Points);
}
#endregion short cut
#region Get the average output for the last 3 games
// Always start with the Average points in their last 3 games, if 0 and QB use 14
if (game != null)
{
if (player.PlayerRole.Equals(Constants.K_ROLE_STARTER))
{
var avgPoints = AveragePoints(player);
// Rookies and injured players may not have played in the last 3 games
if (player.PlayerCat.Equals("1"))
{
if (avgPoints.Equals(0.0M))
{
avgPoints = 14.0M; // avergage for a QB
}
}
if (player.PlayerCat.Equals("2"))
{
if (avgPoints.Equals(0.0M))
{
avgPoints = 8.0M; // avergage for a RB
}
}
if (player.PlayerCat.Equals("3"))
{
if (avgPoints.Equals(0.0M))
{
avgPoints = 6.0M; // avergage for a RB
}
}
else if (player.PlayerCat.Equals("4"))
{
if (avgPoints.Equals(0.0M))
{
avgPoints = 6.0M; // avergage day for a PK
}
}
points += avgPoints;
}
}
#endregion Get the average output for the last 3 games
#region Consider the likely result
decimal spreadModifier = 1; // no modification
if (IncludeSpread)
{
if (game != null)
{
spreadModifier = PlayerSpread(game.GetSpread(), game.IsHome(player.CurrTeam.TeamCode)) / 1;
}
points *= spreadModifier;
}
#endregion Consider the likely result
#region factor in the quality of the opponent
if (IncludeRatingModifier)
{
if (opponent != null)
{
var oppRating = player.OpponentRating(opponent.Ratings);
var ratingModifier = RatingModifier(oppRating);
points *= ratingModifier;
}
}
#endregion factor in the quality of the opponent
player.Points = points;
RankMaster.Add(player.PlayerCode, player); // save points for later
#if DEBUG
// verbose audit trail of the calculations
//Announce(string.Format(
// "{0,-16} has {1,4:#0.#} r pts- spr {2,4:#0.#} avgFP last 3 {3,4:##.#} rating mod {4,4:#0.#} {5}",
// player.PlayerNameShort, points, spreadModifier, avgPoints, ratingModifier, oppRating ) );
#endif
return(points);
}
private void AddPlayerLineWithPlayer(
DataTable dt, bool freeAgent, NFLPlayer p, [Optional] int slotNumber)
{
if (!NotUsed(p) || !IsAvailable(p))
{
return;
}
NFLGame game = null;
if (p.CurrTeam != null)
{
game = p.CurrTeam.GameFor(Season, Week);
}
var dr = dt.NewRow();
if (freeAgent)
{
dr["SLOT"] = "999";
}
else
{
if (slotNumber > 0)
{
dr["SLOT"] = string.Format("{0:00}", slotNumber);
}
else
{
dr["SLOT"] = "Bench";
}
}
if ((p.CurrTeam != null) && (game != null))
{
var opponent = p.CurrTeam.OpponentFor(Season, Week);
// player actually available
dr["PLAYER"] = p.Url(p.PlayerName, forceReport: false);
dr["TEAM"] = p.CurrTeam.TeamCode;
dr["ROLE"] = p.PlayerRole;
dr["POS"] = p.PlayerPos;
dr["PTS"] = RankPoints(p, game, opponent);
dr["GAME"] = $"{game.GameDay()} {game.Hour} {game.OpponentOut( p.CurrTeam.TeamCode )}";
dr["SPREAD"] = game.GetSpread();
dr["TOTAL"] = game.Total;
if (opponent != null)
{
dr["OPPRATE"] = opponent.Ratings;
}
if (game.Played())
{
dr["ACTUAL"] = ActualPoints(p);
}
_usedPlayers.Add(p);
}
dt.Rows.Add(dr);
}
public Decimal RatePlayer(
NFLPlayer plyr,
NFLWeek week,
bool takeCache = true)
{
// Points for Scores and points for stats
if (week.WeekNo.Equals(0))
{
return(0);
}
//TODO: factor in known suspensions
//if (IsSuspended(plyr, week))
// return 0;
if (takeCache)
{
// Check the stats service first
if (YahooStatService.IsStat(
plyr.PlayerCode,
week.Season,
week.Week))
{
return(YahooStatService.GetStat(
plyr.PlayerCode,
week.Season,
week.Week));
}
}
if (plyr.TeamCode == null)
{
Logger.Error("{0} has a null teamcode", plyr);
return(0);
}
GameKey = Week.GameCodeFor(plyr.TeamCode); // slow?
if (string.IsNullOrEmpty(GameKey))
{
return(0);
}
Game = new NFLGame(GameKey);
WeekHasPassed = Game.Played(addDay: false);
if (!WeekHasPassed)
{
return(plyr.Points);
}
Week = week; // set the global week, other wise u will get the same week all the time
plyr.Points = 0; // start from scratch
#region Passing
// 4 pts for a Tdp
var tdpPts = PointsFor(plyr, 4, Constants.K_SCORE_TD_PASS, id: "2");
plyr.Points += tdpPts;
Announce($"{plyr.PlayerName} has {tdpPts} points for Tdp");
// 2 pts for a PAT pass
var ptsForPATpasses = PointsFor(plyr, 2, Constants.K_SCORE_PAT_PASS, id: "2");
plyr.Points += ptsForPATpasses;
Announce($"{plyr.PlayerName} has {ptsForPATpasses} points for PAT passes");
// 1 pt / 25 YDp
var ptsForYDp = PointsForStats(plyr: plyr, increment: 1, forStatType: Constants.K_STATCODE_PASSING_YARDS, divisor: 25.0M);
plyr.Points += ptsForYDp;
Announce($"{plyr.PlayerName} has {ptsForYDp} points for {plyr.ProjectedYDp} YDp");
// -2 pts for an Interception
var ptsForInts = PointsForStats(
plyr: plyr, increment: -1, forStatType: Constants.K_STATCODE_INTERCEPTIONS_THROWN, divisor: 1.0M);
plyr.Points += ptsForInts;
Announce($"{plyr.PlayerName} has {ptsForInts} points for Interceptions");
#endregion Passing
#region Catching
// 6 pts for a TD catch
var ptsForTDcatches = PointsFor(
plyr: plyr,
increment: 6,
forScoreType: Constants.K_SCORE_TD_PASS,
id: "1");
plyr.Points += ptsForTDcatches;
// 2 points for a 2 point conversion
var ptsForPATcatches = PointsFor(
plyr: plyr,
increment: 2,
forScoreType: Constants.K_SCORE_PAT_PASS,
id: "1");
plyr.Points += ptsForPATcatches;
Announce($@"{
plyr.PlayerName
} has {
ptsForPATcatches
} points for PAT catches" );
// 1 pt / 10 yds
var ptsForYDs = PointsForStats(
plyr: plyr,
increment: 1,
forStatType: Constants.K_STATCODE_RECEPTION_YARDS,
divisor: 10.0M);
plyr.Points += ptsForYDs;
Announce($"{plyr.PlayerName} has {ptsForYDs} points for YDc");
// 1/2 pt / 10 yds
var ptsForRecs = PointsForStats(
plyr: plyr,
increment: 1,
forStatType: Constants.K_STATCODE_PASSES_CAUGHT,
divisor: 2.0M);
plyr.Points += ptsForRecs;
Announce($"{plyr.PlayerName} has {ptsForRecs} points for REC");
#endregion Catching
#region Running
// 6 points for TD run
var ptsForTDruns = PointsFor(plyr, 6, Constants.K_SCORE_TD_RUN, id: "1");
plyr.Points += ptsForTDruns;
Announce($"{plyr.PlayerName} has {ptsForTDruns} points for TD runs");
var ptsForPaTruns = PointsFor(plyr, 2, Constants.K_SCORE_PAT_RUN, id: "1");
plyr.Points += ptsForPaTruns;
Announce($"{plyr.PlayerName} has {ptsForPaTruns} points for PAT runs");
// 1 pt / 10 yds
var ptsForYDr = PointsForStats(
plyr: plyr, increment: 1, forStatType: Constants.K_STATCODE_RUSHING_YARDS, divisor: 10.0M);
plyr.Points += ptsForYDr;
Announce($"{plyr.PlayerName} has {ptsForYDr} points for YDr");
#endregion Running
#region Kicking
plyr.Points += PointsFor(plyr, 3, Constants.K_SCORE_FIELD_GOAL, "1");
plyr.Points += PointsFor(plyr, 1, Constants.K_SCORE_PAT, "1");
#endregion Kicking
Announce($@"{
plyr.PlayerName
} has {
plyr.Points
} in week {
week.Season
}:{
week.Week
}" );
return(plyr.Points);
}
public GameSummary(NFLGame game)
{
SummariseGame(game);
}
private void StorePredictedResult(NFLGame game, NFLResult nflResult)
{
PredictionStorer.StorePrediction("nibble", game, nflResult);
}
public string PlayerPiece( NFLPlayer p, NFLGame g, YahooCalculator c )
{
var nextOppTeam = p.NextOpponentTeam( g );
var defensiveRating = nextOppTeam.DefensiveUnit(p.PlayerCat);
var owners = p.LoadAllOwners();
c.Calculate( p, g );
var namePart = string.Format( "<a href='..\\Roles\\{0}-Roles-{1:0#}.htm'>{2}</a>",
p.TeamCode, Week - 1, p.PlayerNameTo( 11 ) );
return string.Format( "{0,-11} {3} {1} {2,2:#0}{5} {4} ",
namePart, defensiveRating, p.Points, owners, ActualOutput(g,p),
DomeBit(g,p));
}
public NFLResult PredictGame(
NFLGame game,
IStorePredictions persistor,
DateTime predictionDate)
{
if (TakeActuals && game.Played())
{
return(game.Result);
}
const int homeRating = 0;
const int awayRating = 0;
if (game.HomeNflTeam == null)
{
game.HomeNflTeam = Masters.Tm.GetTeam(
game.Season + game.HomeTeam);
}
if (game.AwayNflTeam == null)
{
game.AwayNflTeam = Masters.Tm.GetTeam(
game.Season + game.AwayTeam);
}
var homeMetrics = CalculateGameMetrics(
isHome: true,
game: game,
focusDate: predictionDate);
var awayMetrics = CalculateGameMetrics(
isHome: false,
game: game,
focusDate: predictionDate);
var homeScore = homeMetrics.Score;
var awayScore = awayMetrics.Score;
if (homeScore == awayScore)
{
homeScore++; // no ties
}
game.Result = new NFLResult(
game.HomeTeam,
homeScore,
game.AwayTeam,
awayScore)
{
HomeTDp = _homeTDp,
HomeTDr = _homeTDr,
HomeFg = _homeFg,
HomeTDd = _homeTDd,
HomeTDs = _homeTDs,
HomeYDp = homeMetrics.YDp,
HomeYDr = homeMetrics.YDr,
AwayTDr = _awayTDr,
AwayTDp = _awayTDp,
AwayTDs = awayMetrics.TDs,
AwayTDd = awayMetrics.TDd,
AwayYDp = awayMetrics.YDp,
AwayYDr = awayMetrics.YDr,
AwayFg = _awayFg
};
if (AuditTrail)
{
AuditIt(game, game.Result, homeRating, awayRating);
}
if (StorePrediction)
{
StorePredictedResult(
game,
game.Result);
}
// pulled this out to its own job "GameProjectionReportsJob"
//if ( WriteProjection )
// game.WriteProjection();
return(game.Result);
}
public string ActualOutput(NFLGame g, NFLPlayer p)
{
if ( ! g.Played() )
return "____";
Console.WriteLine(g.ScoreOut());
if ( g.GameWeek == null ) g.GameWeek = new NFLWeek(g.Season, g.Week);
var scorer = new YahooScorer(g.GameWeek);
var nScore = scorer.RatePlayer(p, g.GameWeek);
return string.Format(" {0,2:#0} ", nScore);
}
private GameMetrics CalculateGameMetrics(
bool isHome,
NFLGame game,
DateTime focusDate)
{
string teamRatings;
string oppRatings;
var gm = new GameMetrics();
if (isHome)
{
oppRatings = RatingsService.GetUnitRatingsFor(
game.AwayNflTeam,
focusDate);
teamRatings = RatingsService.GetUnitRatingsFor(
game.HomeNflTeam,
focusDate);
// pump up the defence ratings if its divisional game
if (game.IsDivisionalGame())
{
teamRatings = PumpIt(
teamRatings);
}
game.AwayNflTeam.Ratings = oppRatings;
game.HomeNflTeam.Ratings = teamRatings;
}
else
{
teamRatings = RatingsService.GetUnitRatingsFor(
game.AwayNflTeam,
focusDate);
oppRatings = RatingsService.GetUnitRatingsFor(
game.HomeNflTeam,
focusDate);
// pump up the defence ratings if its divisional game
if (game.IsDivisionalGame())
{
oppRatings = PumpIt(
oppRatings);
}
game.HomeNflTeam.Ratings = oppRatings;
game.AwayNflTeam.Ratings = teamRatings;
}
var score = 0;
if (string.IsNullOrEmpty(teamRatings) ||
string.IsNullOrEmpty(oppRatings))
{
Announce("Ratings not found - skipping score calculation");
}
else
{
// Part 0 - Calculate field goals
var fg = isHome ? 2 : 1;
if (game.IsDomeGame())
{
fg++;
}
else
{
if (game.IsBadWeather())
{
fg--;
}
}
// Part 1 - Calculate Tdp
var po = teamRatings.Substring(0, 1);
var pd = oppRatings.Substring(5, 1);
var tdp = TouchdownPasses(po, pd);
var ydp = YardsPassing(po, pd);
gm.TDp = tdp;
gm.YDp = ydp;
// Part 2 - Adjust for protection
var pp = teamRatings.Substring(2, 1);
var pr = oppRatings.Substring(3, 1);
var ppr = ProtectionAdjustment(pp, pr);
tdp += ppr;
if (tdp < 0)
{
tdp = 0;
}
// Part 3 - Calculate Tdr
var ro = teamRatings.Substring(1, 1);
var rd = oppRatings.Substring(4, 1);
var tdr = TouchdownRuns(ro, rd);
var ydr = YardsRushing(ro, rd);
gm.TDp = tdp;
gm.TDr = tdr;
gm.YDr = ydr;
var tdd = DefensiveScores(
game.IsDivisionalGame(),
isHome);
var tds = SpecialTeamScores(
game.IsMondayNight(),
isHome);
gm.TDd = tdd;
gm.TDs = tds;
gm.FG = fg;
//TODO: Short week adjustment
//TODO: Opponent had Route last game adjustment
//TODO: Revenge adjustment
// Total up all the parts of a score
score = (tdp + tdr + tdd + tds) * 7 + (fg * 3);
DumpCalculations(
isHome,
game,
tdr,
pr,
pp,
ro,
tds,
tdd,
rd,
oppRatings,
teamRatings,
ppr,
tdp,
score,
pd,
po,
fg);
if (isHome)
{
_homeTDp = tdp;
_homeTDr = tdr;
_homeFg = fg;
_homeTDd = tdd;
_homeTDs = tds;
_homeYDr = ydr;
_homeYDp = ydp;
}
else
{
_awayTDp = tdp;
_awayTDr = tdr;
_awayFg = fg;
_awayTDd = tdd;
_awayTDs = tds;
_awayYDr = ydr;
_awayYDp = ydp;
}
}
gm.Score = score;
return(gm);
}
public bool Contains( NFLGame game )
{
//TODO: implement
return true;
}
public GameProjection(NFLGame game)
{
Game = game;
}
