public Decimal RatePlayer(NFLPlayer plyr, NFLWeek week)
        {
            // Points for Scores and points for stats
            if (week.WeekNo.Equals(0)) return 0;
            // Only starter or backup will score
            if ( ! ( plyr.PlayerRole.Equals( Constants.K_ROLE_STARTER ) || plyr.PlayerRole.Equals( Constants.K_ROLE_STARTER ) ) )
                return 0;

            Week = week; //  set the global week, other wise u will get the same week all the time
            plyr.Points = 0; //  start from scratch
            var currentWeek = Int32.Parse(Utility.CurrentWeek());

            #region  Passing

            //  determine receiving stats
            decimal YD1p = 0;
            var nGames = 0;
            //  yards receiving will be the average of the last x games

            //  Last week
            var lastWeek = week.PreviousWeek(week, false, true);
            var ds = plyr.LastStats(
                Constants.K_STATCODE_PASSING_YARDS, lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                     plyr.PlayerName, YD1p, lastWeek.WeekKey() ) );

            //  two weeks ago
            var twoWeeksAgo = lastWeek.PreviousWeek(lastWeek, false, true);
            decimal YD2p = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_PASSING_YARDS,
                twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards passing in week {2}",
                                                                  plyr.PlayerName, YD2p, twoWeeksAgo.WeekKey() ) );

            // Three weeks ago
            var threeWeeksAgo = lastWeek.PreviousWeek( twoWeeksAgo, false, true );
            decimal YD3p = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_PASSING_YARDS,
                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards passing in week {2}",
                                                                  plyr.PlayerName, YD3p, threeWeeksAgo.WeekKey() ) );

            if (nGames > 0)
                plyr.TotStats.YDp = (int) (YD1p + YD2p + YD3p)/nGames;

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards passing in last 3 weeks",
                                                     plyr.PlayerName, plyr.TotStats.YDp));

            if (plyr.TotStats.YDp > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals( Constants.K_ROLE_BACKUP))
                {
                    plyr.TotStats.YDp = (plyr.TotStats.YDp/2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                             plyr.PlayerName, plyr.TotStats.YDp));
                }
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDp != 0)
            {
                if (plyr.IsAtHome(Week))
                    plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*1.1);
                else
                    plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*.9);
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                                         plyr.PlayerName, plyr.TotStats.YDp));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDp != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = QbRatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*ratingModifier);
                    Utility.Announce(
                        string.Format("  {0} output modified by {1} to {4} due to opponent ({3}) rating modifier of {2}",
                                      plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode, plyr.TotStats.YDp));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDp != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*1.1);
                        else
                            plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*1.05);
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*0.95);
                        else
                            plyr.TotStats.YDp = (int) (plyr.TotStats.YDp*0.9);
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                             plyr.PlayerName, plyr.TotStats.YDp, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards receiving in week {2}",
                                                     plyr.PlayerName, plyr.TotStats.YDp, Week.WeekNo));

            //  1 pt / 25 yds
            var ptsForYDs = (int) (plyr.TotStats.YDp/25.0M);
            plyr.Points += ptsForYDs;

            if (plyr.TotStats.YDp > 0)
            {
                //  one TD for each 100 yds passing
                plyr.TotStats.Tdp = (plyr.TotStats.YDp/100);
                plyr.Points += plyr.TotStats.Tdp*4;
            }

            Utility.Announce( string.Format( "      {0} has {1} points for YDc", plyr.PlayerName, ptsForYDs ) );

            #endregion

            #region  Catching

            //  determine receiving stats
            decimal YD1c = 0;
            nGames = 0;
            //  yards receiving will be the average of the last x games
            ds = plyr.LastStats( Constants.K_STATCODE_RECEPTION_YARDS,
                lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                     plyr.PlayerName, YD1c, lastWeek.WeekKey()));

            decimal YD2c = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_RECEPTION_YARDS,
                twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                                  plyr.PlayerName, YD2c, twoWeeksAgo.WeekKey() ) );

            decimal YD3c = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_RECEPTION_YARDS,
                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                                  plyr.PlayerName, YD3c, threeWeeksAgo.WeekKey() ) );

            if (nGames > 0)
                plyr.TotStats.YDc = (int) (YD1c + YD2c + YD3c)/nGames;

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards receiving in last 3 weeks",
                                                     plyr.PlayerName, plyr.TotStats.YDc ) );

            if (plyr.TotStats.YDc > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals( Constants.K_ROLE_BACKUP ) )
                {
                    plyr.TotStats.YDc = (plyr.TotStats.YDc/2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                             plyr.PlayerName, plyr.TotStats.YDc));
                }
            }

            /////////////////////////
            //  returner bonus 25 yds
            if (plyr.IsReturner())
            {
                plyr.TotStats.YDc += 25;
                Utility.Announce(string.Format("  {0,-15} returner bonus to {1,4:##0}",
                                                         plyr.PlayerName, plyr.TotStats.YDc));
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDc != 0)
            {
                if (plyr.IsAtHome(Week))
                    plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*1.2);
                else
                    plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*.8);
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                                         plyr.PlayerName, plyr.TotStats.YDc));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDc != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = RatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*ratingModifier);
                    Utility.Announce(string.Format("  {0} output modified by {1} due to opponent ({3}) rating of {2}",
                                                             plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDc != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*1.2);
                        else
                            plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*1.1);
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*0.8);
                        else
                            plyr.TotStats.YDc = (int) (plyr.TotStats.YDc*0.9);
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                             plyr.PlayerName, plyr.TotStats.YDc, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards receiving in week {2}",
                                                     plyr.PlayerName, plyr.TotStats.YDc, Week.WeekNo));

            //  1 pt / 10 yds
            ptsForYDs = (int) (plyr.TotStats.YDc/10.0M);
            plyr.Points += ptsForYDs;

            Utility.Announce( string.Format( "      {0} has {1} points for YDc", plyr.PlayerName, ptsForYDs ) );

            if (plyr.TotStats.YDc > 0)
            {
                //  one TD for each 75 yds caught
                plyr.TotStats.Tdc = (plyr.TotStats.YDc/75);
                plyr.Points += plyr.TotStats.Tdc*6;
            }

            #endregion

            #region  Running

            decimal YD1r = 0;
            nGames = 0;
            //  yards running will be the average of the last x games
            ds = plyr.LastStats( Constants.K_STATCODE_RUSHING_YARDS, lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                     plyr.PlayerName, YD1r, lastWeek.WeekKey() ) );

            decimal YD2r = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_RUSHING_YARDS, twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                                  plyr.PlayerName, YD2r, twoWeeksAgo.WeekKey() ) );

            decimal YD3r = 0;
            ds = plyr.LastStats( Constants.K_STATCODE_RUSHING_YARDS,
                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season );
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                                                  plyr.PlayerName, YD3r, threeWeeksAgo.WeekKey()) );

            if (nGames > 0)
                plyr.TotStats.YDr = (int) (YD1r + YD2r + YD3r)/nGames;

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards rushing in last 3 weeks",
                                                     plyr.PlayerName, plyr.TotStats.YDr));

            if (plyr.TotStats.YDr > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                {
                    plyr.TotStats.YDr = (plyr.TotStats.YDr/2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                             plyr.PlayerName, plyr.TotStats.YDr ) );
                }
            }

            /////////////////////////
            //  returner bonus 25 yds
            if (plyr.IsReturner())
            {
                plyr.TotStats.YDr += 25;
                Utility.Announce(string.Format("  {0,-15} returner bonus to {1,4:##0}",
                                                         plyr.PlayerName, plyr.TotStats.YDr));
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDr != 0)
            {
                if (plyr.IsAtHome(Week))
                    plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*1.2);
                else
                    plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*.8);
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                                         plyr.PlayerName, plyr.TotStats.YDr));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDr != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = RatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*ratingModifier);
                    Utility.Announce(string.Format("  {0} output modified by {1} due to opponent ({3}) rating of {2}",
                                   plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDr != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*1.2);
                        else
                            plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*1.1);
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                            plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*0.8);
                        else
                            plyr.TotStats.YDr = (int) (plyr.TotStats.YDr*0.9);
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                             plyr.PlayerName, plyr.TotStats.YDr, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards rushing in week {2}",
                                                     plyr.PlayerName, plyr.TotStats.YDr, Week.WeekNo));

            //  1 pt / 10 yds
            ptsForYDs = (int) (plyr.TotStats.YDr/10.0M);
            plyr.Points += ptsForYDs;

            Utility.Announce( string.Format( "      {0} has {1} points for YDr", plyr.PlayerName, ptsForYDs ) );

            if (plyr.TotStats.YDr > 0)
            {
                //  one TD for each 75 yds caught
                plyr.TotStats.Tdr = (plyr.TotStats.YDr/75);
                plyr.Points += plyr.TotStats.Tdr*6;
            }

            #endregion

            if (plyr.PlayerCat.Equals(Constants.K_KICKER_CAT))
            {
                #region  Kicking

                //  determine FG
                decimal fg = 0;
                //  FGs will be the average of the last x games
                ds = plyr.LastScores( Constants.K_SCORE_FIELD_GOAL,
                    threeWeeksAgo.WeekNo, lastWeek.WeekNo, lastWeek.Season, "1" );
                foreach (DataRow dr in ds.Tables[0].Rows)
                    fg++;

                Utility.Announce(string.Format("  {0,-15} has {1,4:##0} FG in last 3 weeks",
                                                         plyr.PlayerName, fg ) );

                if (fg > 0)
                    plyr.TotStats.Fg = (int) (fg/3);

                if (plyr.TotStats.Fg > 0)
                {
                    // adjust for role
                    if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                    {
                        plyr.TotStats.YDr = (plyr.TotStats.Fg/2);
                        Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                                 plyr.PlayerName, plyr.TotStats.Fg));
                    }
                }

                /////////////////////////
                //  home bonus
                if (plyr.TotStats.Fg != 0)
                {
                    if (plyr.IsAtHome(Week))
                        plyr.TotStats.Fg++;
                    else
                        plyr.TotStats.Fg--;
                    Utility.Announce(string.Format("  {0,-15} fg adjusted to {1,4:##0} home v away",
                                                             plyr.PlayerName, plyr.TotStats.Fg));
                }

                ///////////////
                //  line factor
                if (plyr.TotStats.Fg != 0)
                {
                    var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                    if (game != null)
                    {
                        if (game.SpreadFavourite().Equals(plyr.TeamCode))
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                                plyr.TotStats.Fg += 2;
                            else
                                plyr.TotStats.Fg ++;
                            plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                        }
                        else
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                                plyr.TotStats.Fg -= 2;
                            else
                                plyr.TotStats.Fg--;
                            plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                        }
                        Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                                 plyr.PlayerName, plyr.TotStats.Fg, plyr.PlayerSpread));

                        plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                    }
                }

                if (plyr.TotStats.Fg < 0) plyr.TotStats.Fg = 0;

                Utility.Announce(string.Format("    {0} is projected for {1} FGs in week {2}",
                                                         plyr.PlayerName, plyr.TotStats.Fg, Week.WeekNo));

                //  1 pt / 10 yds
                decimal ptsForFgs = (int) (plyr.TotStats.Fg*3.0M);
                plyr.Points += ptsForFgs;

                //  determine PAT
                decimal pat = 0;
                //  yards running will be the average of the last x games
                ds = plyr.LastScores(RosterLib.Constants.K_SCORE_PAT, currentWeek - 3, currentWeek - 1, Week.Season, "1");
                foreach (DataRow dr in ds.Tables[0].Rows)
                    pat++;

                Utility.Announce(string.Format("  {0,-15} has {1,4:##0} PATs in last 3 weeks",
                                                         plyr.PlayerName, pat));

                plyr.TotStats.Pat = (int) pat;

                if (plyr.TotStats.Pat > 0)
                    // adjust for role
                    if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                        plyr.TotStats.YDr = (plyr.TotStats.YDr/2);

                /////////////////////////
                //  home bonus
                if (plyr.TotStats.Pat != 0)
                {
                    if (plyr.IsAtHome(Week))
                        plyr.TotStats.Pat++;
                    else
                        plyr.TotStats.Pat--;
                    Utility.Announce(string.Format("  {0,-15} pat adjusted to {1,4:##0} home v away",
                                                             plyr.PlayerName, plyr.TotStats.Pat ) );
                }

                ///////////////
                //  line factor
                if (plyr.TotStats.Pat != 0)
                {
                    var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                    if (game != null)
                    {
                        if (game.SpreadFavourite().Equals(plyr.TeamCode))
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                                plyr.TotStats.Pat += 2;
                            else
                                plyr.TotStats.Pat++;
                            plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                        }
                        else
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                                plyr.TotStats.Pat -= 2;
                            else
                                plyr.TotStats.Pat--;
                            plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                        }
                        Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                        plyr.PlayerName, plyr.TotStats.Pat, plyr.PlayerSpread));

                        plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                    }
                }

                if (plyr.TotStats.Pat < 0) plyr.TotStats.Pat = 0;

                Utility.Announce(string.Format("    {0} is projected for {1} PATs in week {2}",
                                                         plyr.PlayerName, plyr.TotStats.Pat, Week.WeekNo));

                //  1 pt / 10 yds
                decimal ptsForPats = (int) (plyr.TotStats.Pat*1.0M);
                plyr.Points += ptsForPats;

                #endregion
            }

            Utility.Announce( string.Format( "{0} has {1} in week {2}:{3}",
                plyr.PlayerName, plyr.Points, week.Season, week.Week ) );

            return plyr.Points;
        }
Exemple #2
0
        public Decimal RatePlayer(NFLPlayer plyr, NFLWeek week, bool takeCache = true)
        {
            // Points for Scores and points for stats
            if (week.WeekNo.Equals(0))
            {
                return(0);
            }
            // Only starter or backup will score
            if (!(plyr.PlayerRole.Equals(Constants.K_ROLE_STARTER) || plyr.PlayerRole.Equals(Constants.K_ROLE_STARTER)))
            {
                return(0);
            }

            Week        = week;      //  set the global week, other wise u will get the same week all the time
            plyr.Points = 0;         //  start from scratch
            var currentWeek = Int32.Parse(Utility.CurrentWeek());

            #region  Passing

            //  determine receiving stats
            decimal YD1p   = 0;
            var     nGames = 0;
            //  yards receiving will be the average of the last x games

            //  Last week
            var lastWeek = week.PreviousWeek(week, false, true);
            var ds       = plyr.LastStats(
                Constants.K_STATCODE_PASSING_YARDS, lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD1p, lastWeek.WeekKey()));

            //  two weeks ago
            var     twoWeeksAgo = lastWeek.PreviousWeek(lastWeek, false, true);
            decimal YD2p        = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_PASSING_YARDS,
                                twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards passing in week {2}",
                                           plyr.PlayerName, YD2p, twoWeeksAgo.WeekKey()));

            // Three weeks ago
            var     threeWeeksAgo = lastWeek.PreviousWeek(twoWeeksAgo, false, true);
            decimal YD3p          = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_PASSING_YARDS,
                                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3p += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards passing in week {2}",
                                           plyr.PlayerName, YD3p, threeWeeksAgo.WeekKey()));

            if (nGames > 0)
            {
                plyr.TotStats.YDp = (int)(YD1p + YD2p + YD3p) / nGames;
            }

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards passing in last 3 weeks",
                                           plyr.PlayerName, plyr.TotStats.YDp));

            if (plyr.TotStats.YDp > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                {
                    plyr.TotStats.YDp = (plyr.TotStats.YDp / 2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                   plyr.PlayerName, plyr.TotStats.YDp));
                }
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDp != 0)
            {
                if (plyr.IsAtHome(Week))
                {
                    plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * 1.1);
                }
                else
                {
                    plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * .9);
                }
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                               plyr.PlayerName, plyr.TotStats.YDp));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDp != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating      = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = QbRatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * ratingModifier);
                    Utility.Announce(
                        string.Format("  {0} output modified by {1} to {4} due to opponent ({3}) rating modifier of {2}",
                                      plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode, plyr.TotStats.YDp));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDp != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * 1.1);
                        }
                        else
                        {
                            plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * 1.05);
                        }
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * 0.95);
                        }
                        else
                        {
                            plyr.TotStats.YDp = (int)(plyr.TotStats.YDp * 0.9);
                        }
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                   plyr.PlayerName, plyr.TotStats.YDp, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards receiving in week {2}",
                                           plyr.PlayerName, plyr.TotStats.YDp, Week.WeekNo));

            //  1 pt / 25 yds
            var ptsForYDs = (int)(plyr.TotStats.YDp / 25.0M);
            plyr.Points += ptsForYDs;

            if (plyr.TotStats.YDp > 0)
            {
                //  one TD for each 100 yds passing
                plyr.TotStats.Tdp = (plyr.TotStats.YDp / 100);
                plyr.Points      += plyr.TotStats.Tdp * 4;
            }

            Utility.Announce(string.Format("      {0} has {1} points for YDc", plyr.PlayerName, ptsForYDs));

            #endregion

            #region  Catching

            //  determine receiving stats
            decimal YD1c = 0;
            nGames = 0;
            //  yards receiving will be the average of the last x games
            ds = plyr.LastStats(Constants.K_STATCODE_RECEPTION_YARDS,
                                lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD1c, lastWeek.WeekKey()));

            decimal YD2c = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_RECEPTION_YARDS,
                                twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD2c, twoWeeksAgo.WeekKey()));

            decimal YD3c = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_RECEPTION_YARDS,
                                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3c += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD3c, threeWeeksAgo.WeekKey()));

            if (nGames > 0)
            {
                plyr.TotStats.YDc = (int)(YD1c + YD2c + YD3c) / nGames;
            }

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards receiving in last 3 weeks",
                                           plyr.PlayerName, plyr.TotStats.YDc));

            if (plyr.TotStats.YDc > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                {
                    plyr.TotStats.YDc = (plyr.TotStats.YDc / 2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                   plyr.PlayerName, plyr.TotStats.YDc));
                }
            }

            /////////////////////////
            //  returner bonus 25 yds
            if (plyr.IsReturner())
            {
                plyr.TotStats.YDc += 25;
                Utility.Announce(string.Format("  {0,-15} returner bonus to {1,4:##0}",
                                               plyr.PlayerName, plyr.TotStats.YDc));
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDc != 0)
            {
                if (plyr.IsAtHome(Week))
                {
                    plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * 1.2);
                }
                else
                {
                    plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * .8);
                }
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                               plyr.PlayerName, plyr.TotStats.YDc));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDc != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating      = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = RatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * ratingModifier);
                    Utility.Announce(string.Format("  {0} output modified by {1} due to opponent ({3}) rating of {2}",
                                                   plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDc != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * 1.2);
                        }
                        else
                        {
                            plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * 1.1);
                        }
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * 0.8);
                        }
                        else
                        {
                            plyr.TotStats.YDc = (int)(plyr.TotStats.YDc * 0.9);
                        }
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                   plyr.PlayerName, plyr.TotStats.YDc, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards receiving in week {2}",
                                           plyr.PlayerName, plyr.TotStats.YDc, Week.WeekNo));

            //  1 pt / 10 yds
            ptsForYDs    = (int)(plyr.TotStats.YDc / 10.0M);
            plyr.Points += ptsForYDs;

            Utility.Announce(string.Format("      {0} has {1} points for YDc", plyr.PlayerName, ptsForYDs));

            if (plyr.TotStats.YDc > 0)
            {
                //  one TD for each 75 yds caught
                plyr.TotStats.Tdc = (plyr.TotStats.YDc / 75);
                plyr.Points      += plyr.TotStats.Tdc * 6;
            }

            #endregion

            #region  Running

            decimal YD1r = 0;
            nGames = 0;
            //  yards running will be the average of the last x games
            ds = plyr.LastStats(Constants.K_STATCODE_RUSHING_YARDS, lastWeek.WeekNo, lastWeek.WeekNo, lastWeek.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD1r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD1r, lastWeek.WeekKey()));

            decimal YD2r = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_RUSHING_YARDS, twoWeeksAgo.WeekNo, twoWeeksAgo.WeekNo, twoWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD2r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD2r, twoWeeksAgo.WeekKey()));

            decimal YD3r = 0;
            ds = plyr.LastStats(Constants.K_STATCODE_RUSHING_YARDS,
                                threeWeeksAgo.WeekNo, threeWeeksAgo.WeekNo, threeWeeksAgo.Season);
            foreach (DataRow dr in ds.Tables[0].Rows)
            {
                YD3r += Decimal.Parse(dr["QTY"].ToString());
                nGames++;
            }
            Utility.Announce(string.Format("  {0,-15} has {1,4:##0} Yards receiving in week {2}",
                                           plyr.PlayerName, YD3r, threeWeeksAgo.WeekKey()));

            if (nGames > 0)
            {
                plyr.TotStats.YDr = (int)(YD1r + YD2r + YD3r) / nGames;
            }

            Utility.Announce(string.Format("  {0,-15} has averaged {1,4:##0} Yards rushing in last 3 weeks",
                                           plyr.PlayerName, plyr.TotStats.YDr));

            if (plyr.TotStats.YDr > 0)
            {
                // adjust for role
                if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                {
                    plyr.TotStats.YDr = (plyr.TotStats.YDr / 2);
                    Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                   plyr.PlayerName, plyr.TotStats.YDr));
                }
            }

            /////////////////////////
            //  returner bonus 25 yds
            if (plyr.IsReturner())
            {
                plyr.TotStats.YDr += 25;
                Utility.Announce(string.Format("  {0,-15} returner bonus to {1,4:##0}",
                                               plyr.PlayerName, plyr.TotStats.YDr));
            }

            /////////////////////////
            //  home bonus
            if (plyr.TotStats.YDr != 0)
            {
                if (plyr.IsAtHome(Week))
                {
                    plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * 1.2);
                }
                else
                {
                    plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * .8);
                }
                Utility.Announce(string.Format("  {0,-15} average adjusted to {1,4:##0} home v away",
                                               plyr.PlayerName, plyr.TotStats.YDr));
            }

            ///////////////////
            //  opponent factor
            if (plyr.TotStats.YDr != 0)
            {
                var opponent = plyr.CurrTeam.OpponentFor(Week.Season, Week.WeekNo);
                if (opponent != null)
                {
                    var oppRating      = plyr.OpponentRating(opponent.Ratings);
                    var ratingModifier = RatingModifier(plyr.OpponentRating(opponent.Ratings));
                    plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * ratingModifier);
                    Utility.Announce(string.Format("  {0} output modified by {1} due to opponent ({3}) rating of {2}",
                                                   plyr.PlayerName, ratingModifier, oppRating, opponent.TeamCode));
                    plyr.OppRate = oppRating;
                }
            }

            ///////////////
            //  line factor
            if (plyr.TotStats.YDr != 0)
            {
                var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                if (game != null)
                {
                    if (game.SpreadFavourite().Equals(plyr.TeamCode))
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * 1.2);
                        }
                        else
                        {
                            plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * 1.1);
                        }
                        plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                    }
                    else
                    {
                        if (Math.Abs(game.Spread) > 6.5M)
                        {
                            plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * 0.8);
                        }
                        else
                        {
                            plyr.TotStats.YDr = (int)(plyr.TotStats.YDr * 0.9);
                        }
                        plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                    }
                    Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                   plyr.PlayerName, plyr.TotStats.YDr, plyr.PlayerSpread));

                    plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                }
            }

            Utility.Announce(string.Format("    {0} is projected for {1} Yards rushing in week {2}",
                                           plyr.PlayerName, plyr.TotStats.YDr, Week.WeekNo));

            //  1 pt / 10 yds
            ptsForYDs    = (int)(plyr.TotStats.YDr / 10.0M);
            plyr.Points += ptsForYDs;

            Utility.Announce(string.Format("      {0} has {1} points for YDr", plyr.PlayerName, ptsForYDs));

            if (plyr.TotStats.YDr > 0)
            {
                //  one TD for each 75 yds caught
                plyr.TotStats.Tdr = (plyr.TotStats.YDr / 75);
                plyr.Points      += plyr.TotStats.Tdr * 6;
            }

            #endregion

            if (plyr.PlayerCat.Equals(Constants.K_KICKER_CAT))
            {
                #region  Kicking

                //  determine FG
                decimal fg = 0;
                //  FGs will be the average of the last x games
                ds = plyr.LastScores(Constants.K_SCORE_FIELD_GOAL,
                                     threeWeeksAgo.WeekNo, lastWeek.WeekNo, lastWeek.Season, "1");
                foreach (DataRow dr in ds.Tables[0].Rows)
                {
                    fg++;
                }

                Utility.Announce(string.Format("  {0,-15} has {1,4:##0} FG in last 3 weeks",
                                               plyr.PlayerName, fg));

                if (fg > 0)
                {
                    plyr.TotStats.Fg = (int)(fg / 3);
                }

                if (plyr.TotStats.Fg > 0)
                {
                    // adjust for role
                    if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                    {
                        plyr.TotStats.YDr = (plyr.TotStats.Fg / 2);
                        Utility.Announce(string.Format("  {0,-15} average halved to {1,4:##0} due to being a backup",
                                                       plyr.PlayerName, plyr.TotStats.Fg));
                    }
                }

                /////////////////////////
                //  home bonus
                if (plyr.TotStats.Fg != 0)
                {
                    if (plyr.IsAtHome(Week))
                    {
                        plyr.TotStats.Fg++;
                    }
                    else
                    {
                        plyr.TotStats.Fg--;
                    }
                    Utility.Announce(string.Format("  {0,-15} fg adjusted to {1,4:##0} home v away",
                                                   plyr.PlayerName, plyr.TotStats.Fg));
                }

                ///////////////
                //  line factor
                if (plyr.TotStats.Fg != 0)
                {
                    var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                    if (game != null)
                    {
                        if (game.SpreadFavourite().Equals(plyr.TeamCode))
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                            {
                                plyr.TotStats.Fg += 2;
                            }
                            else
                            {
                                plyr.TotStats.Fg++;
                            }
                            plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                        }
                        else
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                            {
                                plyr.TotStats.Fg -= 2;
                            }
                            else
                            {
                                plyr.TotStats.Fg--;
                            }
                            plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                        }
                        Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                       plyr.PlayerName, plyr.TotStats.Fg, plyr.PlayerSpread));

                        plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                    }
                }

                if (plyr.TotStats.Fg < 0)
                {
                    plyr.TotStats.Fg = 0;
                }

                Utility.Announce(string.Format("    {0} is projected for {1} FGs in week {2}",
                                               plyr.PlayerName, plyr.TotStats.Fg, Week.WeekNo));

                //  1 pt / 10 yds
                decimal ptsForFgs = (int)(plyr.TotStats.Fg * 3.0M);
                plyr.Points += ptsForFgs;

                //  determine PAT
                decimal pat = 0;
                //  yards running will be the average of the last x games
                ds = plyr.LastScores(RosterLib.Constants.K_SCORE_PAT, currentWeek - 3, currentWeek - 1, Week.Season, "1");
                foreach (DataRow dr in ds.Tables[0].Rows)
                {
                    pat++;
                }

                Utility.Announce(string.Format("  {0,-15} has {1,4:##0} PATs in last 3 weeks",
                                               plyr.PlayerName, pat));

                plyr.TotStats.Pat = (int)pat;

                if (plyr.TotStats.Pat > 0)
                {
                    // adjust for role
                    if (plyr.PlayerRole.Equals(Constants.K_ROLE_BACKUP))
                    {
                        plyr.TotStats.YDr = (plyr.TotStats.YDr / 2);
                    }
                }


                /////////////////////////
                //  home bonus
                if (plyr.TotStats.Pat != 0)
                {
                    if (plyr.IsAtHome(Week))
                    {
                        plyr.TotStats.Pat++;
                    }
                    else
                    {
                        plyr.TotStats.Pat--;
                    }
                    Utility.Announce(string.Format("  {0,-15} pat adjusted to {1,4:##0} home v away",
                                                   plyr.PlayerName, plyr.TotStats.Pat));
                }

                ///////////////
                //  line factor
                if (plyr.TotStats.Pat != 0)
                {
                    var game = plyr.CurrTeam.GameFor(Week.Season, Week.WeekNo);
                    if (game != null)
                    {
                        if (game.SpreadFavourite().Equals(plyr.TeamCode))
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                            {
                                plyr.TotStats.Pat += 2;
                            }
                            else
                            {
                                plyr.TotStats.Pat++;
                            }
                            plyr.PlayerSpread = string.Format("+{0:#.#}", Math.Abs(game.Spread));
                        }
                        else
                        {
                            if (Math.Abs(game.Spread) > 6.5M)
                            {
                                plyr.TotStats.Pat -= 2;
                            }
                            else
                            {
                                plyr.TotStats.Pat--;
                            }
                            plyr.PlayerSpread = string.Format("-{0:#.#}", Math.Abs(game.Spread));
                        }
                        Utility.Announce(string.Format("  {0} output modified to {1} due to the spread ({2})",
                                                       plyr.PlayerName, plyr.TotStats.Pat, plyr.PlayerSpread));

                        plyr.Opponent = game.OpponentOut(plyr.CurrTeam.TeamCode);
                    }
                }

                if (plyr.TotStats.Pat < 0)
                {
                    plyr.TotStats.Pat = 0;
                }

                Utility.Announce(string.Format("    {0} is projected for {1} PATs in week {2}",
                                               plyr.PlayerName, plyr.TotStats.Pat, Week.WeekNo));

                //  1 pt / 10 yds
                decimal ptsForPats = (int)(plyr.TotStats.Pat * 1.0M);
                plyr.Points += ptsForPats;

                #endregion
            }

            Utility.Announce(string.Format("{0} has {1} in week {2}:{3}",
                                           plyr.PlayerName, plyr.Points, week.Season, week.Week));

            return(plyr.Points);
        }