Exemplo n.º 1
0
        /// <summary>
        /// 計算學習領域成績
        /// </summary>
        /// <param name="defaultRule"></param>
        public void CalculateLearningDomainScore(ScoreCalculator defaultRule)
        {
            foreach (StudentScore student in Students)
            {
                SemesterScore semsscore = student.SemestersScore[SemesterData.Empty];
                SemesterDomainScoreCollection dscores = semsscore.Domain;
                ScoreCalculator rule = student.CalculationRule;

                if (rule == null)
                {
                    rule = defaultRule;
                }

                #region 計算各領域加權平均。
                //計算學習領域成績。
                //decimal? result = CalcDomainWeightAvgScore(dscores, Util.VariableDomains);
                ScoreResult result = CalcDomainWeightAvgScore(dscores, Util.VariableDomains);;
                if (result.Score.HasValue)
                {
                    semsscore.LearnDomainScore = rule.ParseLearnDomainScore(result.Score.Value);
                }

                if (result.ScoreOrigin.HasValue)
                {
                    semsscore.LearnDomainScoreOrigin = rule.ParseLearnDomainScore(result.ScoreOrigin.Value);
                }
                #endregion
            }
        }
Exemplo n.º 2
0
        public void ScoreExample7Test()
        {
            string pFilePath = "test-golfing2.xml";
            string modelname = "golfing";
            string paramList = "outlook=\"sunny\"";

            Pmml pmml = Pmml.loadModels(pFilePath);

            Assert.NotNull(pmml);

            TreeModel tree = (TreeModel)pmml.getByName(modelname);

            Assert.NotNull(tree);

            // Modification for NullPrediction
            tree.MissingValueStrategy = MissingValueStrategy.NullPrediction;

            Dictionary <string, object> lDict = parseParams(paramList);

            ScoreResult result = tree.Score(lDict);

            Assert.NotNull(result);

            Assert.IsNull(result.Value);
        }
Exemplo n.º 3
0
        public async Task <List <ScheduledMatchDto> > GetMatches(RequestDto request)
        {
            //TODO: Refactor

            //Convert the list of selected list to the string of filter
            var codes = GetCompetitionsCodes(request.LeaguesChecked);

            var matchProvider = MatchProvider.Create().With(_httpClient).Build();

            var matches = await matchProvider.GetAllMatches("competitions", codes, "dateFrom", request.StartingDate.ToString("yyyy-MM-dd"), "dateTo", request.EndingDate.ToString("yyyy-MM-dd"));

            var result = new List <ScheduledMatchDto>();

            foreach (var match in matches)
            {
                Enum.TryParse(match.Status.ToUpper(), out Status state);
                ScoreResult scoreResult = new ScoreResult(match.Score.FullTime.HomeTeam, match.Score.FullTime.AwayTeam);

                result.Add(new ScheduledMatchDto(
                               match.HomeTeam.Name,
                               match.AwayTeam.Name,
                               match.UtcDate,
                               state,
                               scoreResult,
                               (int)match.Matchday,
                               new LeagueDto(match.Competition.Name, match.Competition.Area.Name)
                               ));
            }
            //Filter matches with selected status
            result = result.Where(m => request.StatusChecked.Contains(m.Status)).ToList();
            return(result);
        }
Exemplo n.º 4
0
 private void SetScore(ScoreResult result, bool redWinner)
 {
     _playerCache[result.RedOffensive.Id].UpdateScore(result.RedOffensive.ScoreCount, result.Story, redWinner, true);
     _playerCache[result.RedDefensive.Id].UpdateScore(result.RedDefensive.ScoreCount, result.Story, redWinner, false);
     _playerCache[result.BlueOffensive.Id].UpdateScore(result.BlueOffensive.ScoreCount, result.Story, !redWinner, true);
     _playerCache[result.BlueDefensive.Id].UpdateScore(result.BlueDefensive.ScoreCount, result.Story, !redWinner, false);
 }
Exemplo n.º 5
0
        private void AddScoreResults(ScoreResult sr, long playerId)
        {
            ReplayMatchPlayerScoreResult playerScore = new ReplayMatchPlayerScoreResult
            {
                ReplayId               = ReplayId,
                Assists                = sr.Assists,
                PlayerId               = playerId,
                CreepDamage            = sr.CreepDamage,
                DamageTaken            = sr.DamageTaken,
                Deaths                 = sr.Deaths,
                ExperienceContribution = sr.ExperienceContribution,
                Healing                = sr.Healing,
                HeroDamage             = sr.HeroDamage,
                MercCampCaptures       = sr.MercCampCaptures,
                MetaExperience         = sr.MetaExperience,
                MinionDamage           = sr.MinionDamage,
                SelfHealing            = sr.SelfHealing,
                SiegeDamage            = sr.SiegeDamage,
                SoloKills              = sr.SoloKills,
                StructureDamage        = sr.StructureDamage,
                SummonDamage           = sr.SummonDamage,
                TakeDowns              = sr.Takedowns,
                TimeCCdEnemyHeroes     = sr.TimeCCdEnemyHeroes.HasValue ? sr.TimeCCdEnemyHeroes.Value.Ticks : (long?)null,
                TimeSpentDead          = sr.TimeSpentDead,
                TownKills              = sr.TownKills,
                WatchTowerCaptures     = sr.WatchTowerCaptures,
            };

            ReplaysDb.MatchPlayerScoreResult.CreateRecord(ReplaysContext, playerScore);
        }
Exemplo n.º 6
0
        public AIAction Decide(AIInfo aiInfo)
        {
            float cutoff = float.MinValue;

            aiInfo.lastDecisionTime = GameTimer.Instance.GetFrameTimestamp();

            ScoreResult     bestResult = new ScoreResult();
            List <Decision> decisions  = aiInfo.decisions;

            for (int i = 0; i < decisions.Count; i++)
            {
                Decision    decision = decisions[i];
                ScoreResult result   = decision.evaluator.Score(aiInfo.Entity, decision, cutoff);

                if (result.score > cutoff)
                {
                    cutoff     = result.score;
                    bestResult = result;
                }
            }

            bestResult.action.SetContext(bestResult.context);
            aiInfo.action = bestResult.action;
            return(bestResult.action);
        }
Exemplo n.º 7
0
    // only called when we know for sure we have a double plus
    private void ScoreDoublePlus(ScoreResult originalPlus, ScoreResult doublePlus)
    {
        // error checking, just to be sure:
        if (originalPlus == ScoreResult.None || doublePlus == ScoreResult.None)
        {
            // we should never get here
            return;
        }

        // double same
        if (originalPlus == ScoreResult.Same && doublePlus == ScoreResult.Same)
        {
            score += sameDoublePlusPoints;
        }
        // double rainbow https://www.youtube.com/watch?v=OQSNhk5ICTI
        else if (originalPlus == ScoreResult.Rainbow && doublePlus == ScoreResult.Rainbow)
        {
            score += rainbowDoublePlusPoints;
        }
        // double mixed
        else
        {
            score += mixedDoublePlusPoints;
        }
    }
Exemplo n.º 8
0
    void LoadHighscores()
    {
        Func <List <ScoreboardCore.Data.ScoreResult>, bool, bool> callback = (results, success) =>
        {
            if (success)
            {
                m_scoreboardTitleText.text = $"Leaderboard ({m_playerStats.Level})";

                m_scoreboardText.text = "";
                for (int i = 0; i < results.Count; ++i)
                {
                    ScoreResult result = results[i];
                    m_scoreboardText.text += $"{i+1}. {result.Score.User} : {result.Score.ScoreValue} \n";
                }

                m_scoreboardText.gameObject.SetActive(true);
                m_scoreboardTitleText.gameObject.SetActive(true);
            }
            else
            {
            }

            return(true);
        };

        m_scoreboardComponent.GetHighscores(callback, m_playerStats.Level);
    }
Exemplo n.º 9
0
                  "Recurrent", 0)]         // confidence = 83.18%
        public void ScoreTest(string pFilePath, string modelname, string paramList, string res, decimal confidence)
        {
            Pmml pmml = Pmml.loadModels(pFilePath);

            Assert.NotNull(pmml);

            ModelElement model = pmml.getByName(modelname);

            Assert.NotNull(model);

            Assert.IsInstanceOf(typeof(TreeModel), model);
            TreeModel tree = (TreeModel)model;

            Dictionary <string, object> lDict = parseParams(paramList);

            ScoreResult result = tree.Score(lDict);

            Assert.NotNull(result);


            /*foreach(Node item in result.Nodes)
             * {
             *      Console.WriteLine("Node {0} = score {1}", item.Id, item.Score);
             *
             *      foreach(ScoreDistribution it2 in item.ScoreDistributions)
             *              Console.WriteLine("\tScore Dist. {0} ({1}) = {2}", it2.Value, it2.RecordCount, it2.Confidence);
             * }*/

            Assert.AreEqual(res, result.Value);
            Assert.AreEqual(confidence, result.Confidence);
        }
Exemplo n.º 10
0
        public void SimplePredicateIsNotMissingTest()
        {
            string      pmmlStr = @"<?xml version=""1.0"" ?>
<PMML version=""4.1"" xmlns=""http://www.dmg.org/PMML-4_1"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
	<Header copyright=""www.dmg.org"" description=""A very small tree model to test isNotMissing operator.""/>
	<DataDictionary numberOfFields=""2"" >
		<DataField name=""in"" optype=""continuous"" dataType=""double""/>
		<DataField name=""out"" optype=""continuous"" dataType=""double""/>
	</DataDictionary>
	<TreeModel modelName=""SimpleIsNotMissingTest"" functionName=""classification"">
		<MiningSchema>
			<MiningField name=""in""/>
			<MiningField name=""out"" usageType=""predicted""/>
		</MiningSchema>
		<Node score=""0"">
			<True/>
			<Node score=""1"">
				<SimplePredicate field=""in"" operator=""isNotMissing"" />
			</Node>
		</Node>
	</TreeModel>
</PMML>
";
            XmlDocument xml     = new XmlDocument();

            xml.LoadXml(pmmlStr);
            Pmml pmml = Pmml.loadModels(xml);

            ScoreResult res = pmml.getByName("SimpleIsNotMissingTest").Score(parseParams("  in=\"foo\"  "));

            Assert.AreEqual("1", res.Value);
        }
Exemplo n.º 11
0
    void Score()
    {
        List <ScoreResult> playerScores = new List <ScoreResult>();

        foreach (int id in playerList)
        {
            BattlerData battlerData = battlers[id];
            ScoreResult score       = new ScoreResult();

            foreach (int targetID in targetList)
            {
                if (battlerData.againstList.Contains(targetID))
                {
                    score.against += 1;
                }
                if (battlerData.counterList.Contains(targetID))
                {
                    score.counter += 1;
                }
            }
            playerScores.Add(score);
        }

        RefreshScoreLayout(playerScores);
    }
Exemplo n.º 12
0
        private void ScoreRequestCompleted(AsyncOperation obj)
        {
            UnityWebRequestAsyncOperation oper = obj as UnityWebRequestAsyncOperation;
            UnityWebRequest www = oper.webRequest;

            string unique_identifier = SystemInfo.deviceUniqueIdentifier;

            string[] segments = www.url.Split('/');
            string   code     = "";

            if (segments.Length > 0)
            {
                code = Decrypt(segments[segments.Length - 1], unique_identifier);
            }

            if (www.isNetworkError || www.isHttpError)
            {
                Debug.Log(www.error);
                bool should_add = hashes.Contains(sha256_hash(code)) && !Scores.ContainsKey(code);

                try
                {
                    scoreResult(should_add, code);
                }
                finally
                {
                    if (should_add)
                    {
                        Scores.Add(code, ReportingState.NONE);
                    }
                    www.Dispose();
                }
            }
            else
            {
                // Show results as text
                //Debug.Log(www.downloadHandler.text);
                ScoreResult result = ScoreResult.CreateFromJSON(www.downloadHandler.text);

                try
                {
                    scoreResult(result.success, code);
                }
                finally
                {
                    if (!Scores.ContainsKey(code))
                    {
                        Scores.Add(code, ReportingState.NONE);
                    }

                    if (result.success && Scores[code] != ReportingState.REPORTED)
                    {
                        Scores[code] = ReportingState.REPORTED;
                    }
                    www.Dispose();
                }
            }
        }
Exemplo n.º 13
0
        public ScoreResult Eval(int[] dice)
        {
            var result = new ScoreResult();

            result.DiceUsed = dice.Where(d => d == _dieValue).ToArray();
            result.Score    = result.DiceUsed.Count() * _score;
            result.RuleUsed = this;
            return(result);
        }
Exemplo n.º 14
0
        public ScoreResult CurrentFrameScore()
        {
            var result = new ScoreResult
            {
                ScoreType = IsFinalScore() ? ScoreStatus.Final : ScoreStatus.Temporary,
                Score     = PinsDroppedOfAThrow.Sum() + PinsDroppedOfABonusBall.Sum()
            };

            return(result);
        }
Exemplo n.º 15
0
        public void RandomTest(string pFilePath)
        {
            Pmml pmml = Pmml.loadModels(pFilePath);

            Assert.NotNull(pmml);

            ScoreResult res = pmml.Models[0].Score(new Dictionary <string, object>());

            Assert.IsNotNull(res);
        }
Exemplo n.º 16
0
        /// <summary>
        /// 選択されているスコアデータを編集する。
        /// </summary>
        private void ScoreDataEdit()
        {
            // Get selected item
            ScoreResult scoreResult = null;
            int         selectedRow = 0;

            // Get selected row
            foreach (DataGridViewCell cell in ScoreDataGridView.SelectedCells)
            {
                selectedRow = cell.RowIndex;
                scoreResult = (ScoreResult)ScoreDataGridView.Rows[selectedRow].DataBoundItem;
                break;
            }

            // If can't selected, no action
            if (scoreResult == null)
            {
                return;
            }

            // Load id and open window
            int?musicId = GetTreeViewSelectedMusicId();

            // If can't get music id, no action
            if (musicId == null)
            {
                return;
            }

            // Get music object from Music ID
            MusicDao musicDao = new MusicDao(databaseFilePath);
            Music    music    = musicDao.selectByMusicId(musicId);

            music.scoreResultList = new List <ScoreResult>();
            music.scoreResultList.Add(scoreResult);

            using (RegistScoreConfirmForm registScoreConfirmForm = new RegistScoreConfirmForm(ref music, ref music))
            {
                if (DialogResult.OK == registScoreConfirmForm.ShowDialog())
                {
                    // Regist data
                    musicDao.InsertOrReplace(music);

                    // Reflesh view
                    RefreshScoreDataGridView();

                    MessageBox.Show("スコアデータの修正が完了しました。");
                }
                else
                {
                    // cancel
                    return;
                }
            }
        }
Exemplo n.º 17
0
        public void CalculateElo_AdjustScoresWhenDifferent_PlayerTwoWin()
        {
            var playerOne = new ScoreResult("p1", 1700);
            var playerTwo = new ScoreResult("p2", 1300);

            ScoreResult[] scores = { playerOne, playerTwo };

            var newScores = scoreCalculator.Calculate(scores, "p2");

            Assert.IsTrue(newScores[0].Score == 1671 && newScores[1].Score == 1329, "Player One's score should correctly increase proportional to eloK.");
        }
Exemplo n.º 18
0
        public void CalculateElo_AdjustScoresWhenSame()
        {
            var playerOne = new ScoreResult("p1", 1500);
            var playerTwo = new ScoreResult("p2", 1500);

            ScoreResult[] scores = { playerOne, playerTwo };

            var newScores = scoreCalculator.Calculate(scores, "p1");

            Assert.IsTrue(newScores[0].Score == 1516 && newScores[1].Score == 1484, "Player One's score should correctly increase proportional to eloK.");
        }
Exemplo n.º 19
0
    public ScoreResult GetScoreResult(int[] diceRollValues)
    {
        var result = new ScoreResult();

        if (diceRollValues.All(x => win.Contains(x)))
        {
            result.Multiplier = 2;
        }

        return(result);
    }
Exemplo n.º 20
0
        public ScoreResult GetCurrentScores()
        {
            var result = new ScoreResult();

            foreach (var frame in Frames)
            {
                var frameScore = frame.CurrentFrameScore();
                result.ScoreType = frameScore.ScoreType == ScoreStatus.Final ? ScoreStatus.Final : ScoreStatus.Temporary;
                result.Score    += frameScore.Score;
            }

            return(result);
        }
Exemplo n.º 21
0
        /// <summary>
        /// 対象のスコアリザルトを削除する。
        /// </summary>
        /// <param name="scoreResult">削除対象のスコアリザルト</param>
        /// <returns>true:登録成功、false:登録失敗</returns>
        public bool DeleteScoreResult(ScoreResult scoreResult)
        {
            // return value initialized with false
            bool result = false;

            logger.Info("Music dao insert or replace start.");
            logger.Info("Target score data id = " + scoreResult.id);

            // database access section
            using (SqliteConnection connection = new SqliteConnection(builder.ToString()))
            {
                // connection open
                connection.Open();

                // enable transaction
                using (SqliteTransaction transaction = connection.BeginTransaction())
                    using (SqliteCommand command = connection.CreateCommand())
                    {
                        // SQL
                        command.CommandText = "DELETE FROM T_SCORE_RECORD WHERE @id = id;";

                        // query to log
                        logger.Info(command.CommandText);

                        // prepared statement
                        command.Parameters.AddWithValue("id", scoreResult.id);

                        // execute
                        if (command.ExecuteNonQuery() == 1)
                        {
                            logger.Info("Delete result is ok.");
                        }
                        else
                        {
                            logger.Info("Delete result NG!");
                            throw new SqliteException("Delete count is ng, not 1.", 5000);
                        }

                        // clear parameters
                        command.Parameters.Clear();

                        // commit
                        transaction.Commit();

                        // successful all command
                        result = true;
                    }
            }

            return(result);
        }
Exemplo n.º 22
0
        public IRule BestRule(int[] dice)
        {
            ScoreResult bestResult = new ScoreResult();

            foreach (var rule in _rules)
            {
                var result = rule.Eval(dice);
                if (result.Score > bestResult.Score)
                {
                    bestResult = result;
                }
            }
            return(bestResult.RuleUsed);
        }
Exemplo n.º 23
0
        public void ScoreExample1Test()
        {
            string  pFilePath  = "test-ruleset1.xml";
            string  modelname  = "NestedDrug";
            string  paramList  = "BP='HIGH', K=0.0621, Age = 36, Na = 0.5023";
            string  res        = "may play";
            decimal confidence = 0.47M;

            Pmml pmml = Pmml.loadModels(pFilePath);

            Assert.NotNull(pmml);

            ModelElement model = pmml.getByName(modelname);

            Assert.NotNull(model);

            Assert.IsInstanceOf <RuleSetModel>(model);

            RuleSetModel rs = (RuleSetModel)model;

            // Check exemple 1 as 3 RuleSelectionMethod for first node
            Assert.IsNotNull(rs.RuleSet);
            Assert.IsNotNull(rs.RuleSet.RuleSelectionMethods);
            Assert.AreEqual(3, rs.RuleSet.RuleSelectionMethods.Count);

            // Check 3 Rule
            Assert.AreEqual(3, rs.RuleSet.Rules.Count);

            // Modification for aggregateNode
            //tree.MissingValueStrategy = MissingValueStrategy.AggregateNodes;

            Dictionary <string, object> lDict = parseParams(paramList);

            ScoreResult result = rs.Score(lDict);

            Assert.NotNull(result);


            /*foreach(Node item in result.Nodes)
             * {
             *      Console.WriteLine("Node {0} = score {1}", item.Id, item.Score);
             *
             *      foreach(ScoreDistribution it2 in item.ScoreDistributions)
             *              Console.WriteLine("\tScore Dist. {0} ({1}) = {2}", it2.Value, it2.RecordCount, it2.Confidence);
             * }*/

            Assert.AreEqual(res, result.Value);
            Assert.AreEqual(confidence, result.Confidence);
        }
Exemplo n.º 24
0
    public ScoreResult GetScoreResult(int[] diceRollValues)
    {
        var result = new ScoreResult();

        for (int i = 1; i <= 6; i++)
        {
            if (diceRollValues.Count(x => x == i) == 3)
            {
                result.Multiplier = 3;
                break;
            }
        }

        return(result);
    }
Exemplo n.º 25
0
        public void ScoreCarfTest(string paramList, string res, decimal confidence)
        {
            string pFilePath = "models\\RuleSetCarrefour.xml";
            string modelname = "CARF-20140124";

            Pmml pmml = Pmml.loadModels(pFilePath);

            Assert.NotNull(pmml);

            ModelElement model = pmml.getByName(modelname);

            Assert.NotNull(model);

            Assert.IsInstanceOf <RuleSetModel>(model);

            RuleSetModel rs = (RuleSetModel)model;

            // Check CARF as 1 RuleSelectionMethod for first node
            Assert.IsNotNull(rs.RuleSet);
            Assert.IsNotNull(rs.RuleSet.RuleSelectionMethods);
            Assert.AreEqual(1, rs.RuleSet.RuleSelectionMethods.Count);
            Assert.AreEqual("firstHit", rs.RuleSet.RuleSelectionMethods[0].Criterion);

            // Check 11 Rule
            Assert.AreEqual(11, rs.RuleSet.Rules.Count);

            // Modification for aggregateNode
            //tree.MissingValueStrategy = MissingValueStrategy.AggregateNodes;

            Dictionary <string, object> lDict = parseParams(paramList);
            //for

            ScoreResult result = rs.Score(lDict);

            Assert.NotNull(result);


            /*foreach(Node item in result.Nodes)
             * {
             *      Console.WriteLine("Node {0} = score {1}", item.Id, item.Score);
             *
             *      foreach(ScoreDistribution it2 in item.ScoreDistributions)
             *              Console.WriteLine("\tScore Dist. {0} ({1}) = {2}", it2.Value, it2.RecordCount, it2.Confidence);
             * }*/

            Assert.AreEqual(res, result.Value);
            Assert.AreEqual(confidence, result.Confidence);
        }
Exemplo n.º 26
0
        private static ScoreResult CalcDomainWeightAvgScore(SemesterDomainScoreCollection dscores, UniqueSet <string> excludeItem)
        {
            decimal TotalScore = 0, TotalScoreOrigin = 0, TotalWeight = 0;

            foreach (string strDomain in dscores)
            {
                // 高雄語文只顯示不計算
                if (Program.Mode == ModuleMode.KaoHsiung)
                {
                    if (strDomain == "語文")
                    {
                        continue;
                    }
                }

                if (excludeItem.Contains(strDomain.Trim()))
                {
                    continue;
                }

                SemesterDomainScore dscore = dscores[strDomain];
                if (dscore.Value.HasValue && dscore.Weight.HasValue)          //dscore.Value 是原來的結構。
                {
                    TotalScore += (dscore.Value.Value * dscore.Weight.Value); //擇優成績。

                    if (dscore.ScoreOrigin.HasValue)
                    {
                        TotalScoreOrigin += (dscore.ScoreOrigin.Value * dscore.Weight.Value); //原始成績。
                    }
                    else
                    {
                        TotalScoreOrigin += (dscore.Value.Value * dscore.Weight.Value); //將擇優當成原始。
                    }
                    TotalWeight += dscore.Weight.Value;                                 //比重不會因為哪種成績而不同。
                }
            }

            if (TotalWeight <= 0)
            {
                return(new ScoreResult());                  //沒有成績。
            }
            ScoreResult sr = new ScoreResult();

            sr.Score       = TotalScore / TotalWeight;
            sr.ScoreOrigin = TotalScoreOrigin / TotalWeight;

            return(sr);
        }
Exemplo n.º 27
0
    public ScoreResult Validate(int[] diceRollValues)
    {
        var result = new ScoreResult();

        foreach (var rule in scoreRules)
        {
            result = rule.Value.GetScoreResult(diceRollValues);

            if (result.IsFault || result.Multiplier > 0 || result.Score > 0)
            {
                break;
            }
        }

        return(result);
    }
Exemplo n.º 28
0
        public List <ScoreResult> GetScoreResultList()
        {
            var _scoreResults = new List <ScoreResult>();
            var x             = 0;

            foreach (Score _score in Players[0].Scorecard.ScoreList)
            {
                var _newResult = new ScoreResult
                {
                    Name = _score.Name,
                };
                try
                {
                    if (Players[0] != null)
                    {
                        _newResult.PlayerOne = Players[0].Scorecard.ScoreList[x].Value;
                    }
                    if (Players[1] != null)
                    {
                        _newResult.PlayerTwo = Players[1].Scorecard.ScoreList[x].Value;
                    }
                    if (Players[2] != null)
                    {
                        _newResult.PlayerThree = Players[2].Scorecard.ScoreList[x].Value;
                    }
                    if (Players[3] != null)
                    {
                        _newResult.PlayerFour = Players[3].Scorecard.ScoreList[x].Value;
                    }
                    if (Players[4] != null)
                    {
                        _newResult.PlayerFive = Players[4].Scorecard.ScoreList[x].Value;
                    }
                }
                catch (ArgumentOutOfRangeException)
                {
                }
                finally
                {
                    _scoreResults.Add(_newResult);
                    x++;
                }
            }

            AllPlayerScores = _scoreResults;
            return(_scoreResults);
        }
        public void Evaluate(ScoringRules rules)
        {
            if (Status != CallForSpeechStatus.New)
            {
                throw new ApplicationException("Cannot accept application that isn't new");
            }

            ScoreResult = rules.Evaluate(this);
            if (!ScoreResult.IsRed())
            {
                Status = CallForSpeechStatus.EvaluatedByMachine;
            }
            else
            {
                Status = CallForSpeechStatus.Rejected;
            }
        }
        public ExecutionStatus TryEvaluate(ScoringRules rules)
        {
            if (Status != CallForSpeechStatus.New)
            {
                return(ExecutionStatus.LogicError("Cannot accept application that isn't new"));
            }

            ScoreResult = rules.Evaluate(this);
            if (!ScoreResult.IsRed())
            {
                Status = CallForSpeechStatus.EvaluatedByMachine;
            }
            else
            {
                Status = CallForSpeechStatus.Rejected;
            }
            return(ExecutionStatus.LogicOk());
        }
Exemplo n.º 31
0
    // check the whole grid to see if there is a valid score
    private void CheckForScore()
    {
        // a helper variable to track score results
        ScoreResult[,] scoreResults = new ScoreResult[gridWidth, gridHeight];

        // avoid checking the top or bottom rows, or left or right edges
        for (int x = 1; x < gridWidth - 1; x++) {
            for (int y = 1; y < gridHeight - 1; y++) {
                // check for a plus once, store the result, and then do game logic later.
                // This way, we avoid checking and rechecking the same cubes over and over.
                scoreResults[x,y] = CheckForPlus (x, y);
            }
        }

        // look at the results and see if we find any double pluses or regular pluses
        for (int x = 1; x < gridWidth - 1; x++) {
            for (int y = 1; y < gridHeight - 1; y++) {

                // if we don't have a score
                if (scoreResults[x,y] == ScoreResult.None) {
                    continue; // this continues to the next iteration of the for() loop
                }

                // Otherwise, we have a valid plus of some sort,
                // so we turn this group of cubes gray
                CreateGrayPlus(x, y);

                // do we have a horizontal double plus, within the bounds of the grid?
                // NOTE: if the first comparison is false (x < gridWidth-3), the second comparison won't ever be checked.
                // Therefore, the order of these comparisons is important here, to avoid going outside the grid and getting an ArrayOutOfBounds exception
                if (x < gridWidth - 3 && scoreResults[x+2, y] != ScoreResult.None) {
                    CreateGrayPlus(x+2, y);
                    ScoreDoublePlus(scoreResults[x,y], scoreResults[x+2, y]);
                    // change the double plus score result to none to avoid double counting it
                    scoreResults[x+2, y] = ScoreResult.None;
                }

                // do we have a vertical double plus, within the bounds of the grid?
                // NOTE: if the first comparison is false (y < gridHeight-3), the second comparison won't ever be checked.
                // Therefore, the order of these comparisons is important here, to avoid going outside the grid and getting an ArrayOutOfBounds exception
                else if (y < gridHeight - 3 && scoreResults[x, y+2] != ScoreResult.None) {
                    CreateGrayPlus(x, y+2);
                    ScoreDoublePlus(scoreResults[x,y], scoreResults[x, y+2]);
                    // change the double plus score result to none to avoid double counting it
                    scoreResults[x, y+2] = ScoreResult.None;
                }

                // no double plus, just a normal plus result
                else {
                    if (scoreResults[x,y] == ScoreResult.Same) {
                        score += samePlusPoints;
                    }
                    else if (scoreResults[x,y] == ScoreResult.Rainbow) {
                        score += rainbowPlusPoints;
                    }
                }
            }
        }
    }
Exemplo n.º 32
0
    // only called when we know for sure we have a double plus
    private void ScoreDoublePlus(ScoreResult originalPlus, ScoreResult doublePlus)
    {
        // error checking, just to be sure:
        if (originalPlus == ScoreResult.None || doublePlus == ScoreResult.None) {
            // we should never get here
            return;
        }

        // double same
        if (originalPlus == ScoreResult.Same && doublePlus == ScoreResult.Same) {
            score += sameDoublePlusPoints;
        }
        // double rainbow https://www.youtube.com/watch?v=OQSNhk5ICTI
        else if (originalPlus == ScoreResult.Rainbow && doublePlus == ScoreResult.Rainbow) {
            score += rainbowDoublePlusPoints;
        }
        // double mixed
        else {
            score += mixedDoublePlusPoints;
        }
    }