Beispiel #1
0
        private void StrengthOfSchedule(List <CTeam> ties)
        {
            /* -----------------------------------------------------------------------------------
            * Combined record of all opponents.
            * If you play a team twice, does it count twice. I say yes.
            * ----------------------------------------------------------------------------------*/
            var msg = new StringBuilder("Str. of schedule: ");

            foreach (var t in ties)
            {
                Record rec = default(Record);
                foreach (var g in t.teamSchedule)
                {
                    CTeam opp = g.Opp(t);
                    rec += opp.simRec.league; //Do not check if t was winner,just accumulate opp's rec.
                }
                t.Metric += 's' + rec.spct;
                if (detailMode)
                {
                    msg.Append(t.teamTag + ":" + rec.wltString + " ");
                }
            }
            if (detailMode)
            {
                tieBreakerSummary.AppendLine(" " + msg.ToString());
            }
        }
Beispiel #2
0
 public /*Constructor*/ CGame(CTeam vis, CTeam home, ESite site)
 {
     // -----------------------------------------------------------------
     // Constructor:
     this.TeamH  = home;
     this.TeamV  = vis;
     this.Site   = site;
     this.Spread = null; // PlayGame() will use power ratings
     ComputeHomeProb();
 }
Beispiel #3
0
 public CTeam Opp(CTeam t)
 {
     // -------------------------------------------------------------
     if (t == this.TeamH)
     {
         return(this.TeamV);
     }
     if (t == this.TeamV)
     {
         return(this.TeamH);
     }
     return(null);
 }
Beispiel #4
0
 public bool Involves(CTeam t)
 {
     // -------------------------------------------------------------
     return(this.TeamH == t || this.TeamV == t);
 }
Beispiel #5
0
        public void BumpRecs(
            CTeam winner, CTeam loser, bool tie, EMode mode)
        {
            // ---------------------------------------------------------------
            bool isDiv  = TeamV.divName == TeamH.divName;
            bool isConf = TeamV.confName == TeamH.confName;

            if (!tie)
            {
                switch (mode)
                {
                case EMode.Real:
                    winner.realRec.league.w++; loser.realRec.league.l++;
                    if (isDiv)
                    {
                        winner.realRec.div.w++; loser.realRec.div.l++;
                    }
                    if (isConf)
                    {
                        winner.realRec.conf.w++; loser.realRec.conf.l++;
                    }
                    break;

                case EMode.Sim:
                    winner.simRec.league.w++; loser.simRec.league.l++;
                    if (isDiv)
                    {
                        winner.simRec.div.w++; loser.simRec.div.l++;
                    }
                    if (isConf)
                    {
                        winner.simRec.conf.w++; loser.simRec.conf.l++;
                    }
                    break;
                }
            }
            else //tie
            {
                switch (mode)
                {
                case EMode.Real:
                    TeamV.realRec.league.t++; TeamH.realRec.league.t++;
                    if (isDiv)
                    {
                        TeamV.realRec.div.t++; TeamH.realRec.div.t++;
                    }
                    if (isConf)
                    {
                        TeamV.realRec.conf.t++; TeamH.realRec.conf.t++;
                    }
                    break;

                case EMode.Sim:
                    TeamV.simRec.league.t++; TeamH.simRec.league.t++;
                    if (isDiv)
                    {
                        TeamV.simRec.div.t++; TeamH.simRec.div.t++;
                    }
                    if (isConf)
                    {
                        TeamV.simRec.conf.t++; TeamH.simRec.conf.t++;
                    }
                    break;
                }
            }
        }
Beispiel #6
0
        public void PlayGame(bool noTies = false)
        {
            /* -----------------------------------------------
             * This sets the following:
             * Winner, Losr, WasTie, Result (EResult)
             * nTies=true is for post-season
             * ----------------------------------------------- */


            // First, check if the game is overriden... (-bc 1807.01)
            switch (this.Override)
            {
            case EResult.NotPlayed:
                // This means not overriden, take no action here.
                break;

            case EResult.HomeWin:
                Winner = TeamH; Loser = TeamV; WasTie = false;
                Result = EResult.HomeWin;
                //Debug.WriteLine(WeekNo.ToString() + " Override: " + TeamH.teamTag + " / " + TeamV.teamTag);
                return;

            case EResult.VisWin:
                Winner = TeamV; Loser = TeamH; WasTie = false;
                Result = EResult.VisWin;
                //Debug.WriteLine(WeekNo.ToString() + " Override: " + TeamV.teamTag + " / " + TeamH.teamTag);
                return;

            case EResult.Tie:
                // Currently app does not allow override as tie, but maybe future...
                Winner = null; Loser = null; WasTie = true;
                Result = EResult.Tie;
                //Debug.WriteLine(WeekNo.ToString() + " Override: " + TeamV.teamTag + " ties " + TeamH.teamTag);
                return;
            }

            // Game is not overriden, so roll the dice...
            double tieProb = (noTies ? 0.0 : 0.01);
            double r       = CSeason.rn.NextDouble(); //Roll the dice...

            if (r < tieProb)
            {
                // Tie game...
                Winner = null; Loser = null; WasTie = true;
                //BumpRecs(TeamH, TeamV, true, EMode.Sim);
                Result = EResult.Tie;
                //Debug.WriteLine(WeekNo.ToString() + " Simulated: " + TeamV.teamTag + " ties " + TeamH.teamTag);
            }
            else if (r < HomeProb + (1.0 - HomeProb) * tieProb)   //tieProb + prob*(1- tieProb))
            // Home team wins...
            {
                Winner = TeamH; Loser = TeamV; WasTie = false;
                //BumpRecs(TeamH, TeamV, false, EMode.Sim);
                Result = EResult.HomeWin;
                //Debug.WriteLine(WeekNo.ToString() + " Simulated: " + TeamH.teamTag + " / " + TeamV.teamTag);
            }
            else
            {
                // Vis team wins...
                Winner = TeamV; Loser = TeamH; WasTie = false;
                //BumpRecs(TeamV, TeamH, false, EMode.Sim);
                Result = EResult.VisWin;
                //Debug.WriteLine(WeekNo.ToString() + " Simulated: " + TeamV.teamTag + " / " + TeamH.teamTag);
            }
        }
Beispiel #7
0
        public /*constructor*/ CGame(string[] arec, int i)
        {
            // --------------------------------------------------
            // Constructor:
            int    wk   = int.Parse(arec[0]);
            string tagV = arec[1];
            string tagH = arec[2];

            char  res    = arec[3][0];
            int   scoreV = res == 'P' ? int.Parse(arec[4]) : 0;
            int   scoreH = res == 'P' ? int.Parse(arec[5]) : 0;
            ESite site   = arec[3].Length > 1 && arec[3][1] == '*' ? ESite.Nuetral : ESite.Home;

            double?spread;

            if (res == 'N' && arec.Length > 4)
            {
                spread = double.Parse(arec[4]);
            }
            else
            {
                spread = null;
            }

            WeekNo     = wk;
            GameNumber = i;
            TeamIdV    = CTeam.teamIndexes[tagV];
            TeamIdH    = CTeam.teamIndexes[tagH];
            ScoreV     = scoreV;
            ScoreH     = scoreH;
            Site       = site;
            Spread     = spread;

            TeamV = CSeason.Teams[TeamIdV];
            TeamH = CSeason.Teams[TeamIdH];
            switch (res)
            {
            case 'P':
                if (scoreV > scoreH)
                {
                    Result = EResult.VisWin;
                }
                else if (scoreV < scoreH)
                {
                    Result = EResult.HomeWin;
                }
                else
                {
                    Result = EResult.Tie;
                }
                OrigResult = Result;
                switch (Result)
                {
                case EResult.HomeWin:
                    BumpRecs(TeamH, TeamV, false, EMode.Real);
                    Winner = TeamH; Loser = TeamV; WasTie = false;
                    break;

                case EResult.VisWin:
                    BumpRecs(TeamV, TeamH, false, EMode.Real);
                    Winner = TeamV; Loser = TeamH; WasTie = false;
                    break;

                case EResult.Tie:
                    BumpRecs(TeamV, TeamH, true, EMode.Real);
                    Winner = null; Loser = null; WasTie = true;
                    break;
                }
                break;

            case 'N':
                Result     = EResult.NotPlayed;
                OrigResult = EResult.NotPlayed;
                ComputeHomeProb();
                break;
            }
        }
Beispiel #8
0
        private void GamesVsCommonOpponents(List <CTeam> ties)
        {
            /* -----------------------------------------------------------------------------------
            * Found this on Reddit... I think it's correct. The 4-minimum referes to the
            * number of common opps, not the number of games, which can differ...
            *
            * It's based on winning percentage, and there must be at least 4 common opponents
            * for it to apply.
            * Consider a scenario where teams A and B are tied up to the common games tie-breaker.
            * Team A played teams W, X, Y, and Z and had a record of 2-2.
            * Team B played teams W, X, Y once each and team Z twice, with a record of 2-3.
            * In this case team A wins the tie-breaker.
            * ----------------------------------------------------------------------------------*/
            StringBuilder msg  = new StringBuilder("Games vs common opps: ");
            List <CTeam>  opps = CommonOpponents(ties);
            Record        rec;

            if (opps.Count < 4)
            {
                foreach (var t in ties)
                {
                    t.Metric += "oXXX";
                }
                if (detailMode)
                {
                    msg.Append("Less than 4 common opps");
                }
            }
            else
            {
                foreach (var t in ties)
                {
                    rec = default(Record);
                    foreach (var g in t.teamSchedule)
                    {
                        CTeam opp = g.Opp(t);
                        if (opps.Contains(opp) && !ties.Contains(opp))
                        {
                            if (g.Winner == t)
                            {
                                rec.w++;
                            }
                            else if (g.WasTie)
                            {
                                rec.t++;
                            }
                            else
                            {
                                rec.l++;
                            }
                        }
                    }
                    t.Metric += 'o' + rec.spct;
                    if (detailMode)
                    {
                        msg.Append(t.teamTag + ":" + rec.wltString + " ");
                    }
                }
            }
            if (detailMode)
            {
                tieBreakerSummary.AppendLine(" " + msg.ToString());
            }
        }