示例#1
0
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 10;
            int nCorrect = 1;
            int nWrong   = 5;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case ToboganVariation.LetterInAWord:
                builder = new LettersInWordQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);
                break;

            case ToboganVariation.SunMoon:
                builder = new WordsBySunMoonQuestionBuilder(nPacks, parameters: builderParams);
                break;
            }

            if (builder == null)
            {
                throw new System.Exception("No question builder defined for variation " + Variation.ToString());
            }

            return(builder);
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks = 10;
            int nWrong = 4;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case ThrowBallsVariation.letters:
                builder = new RandomLettersQuestionBuilder(nPacks, 1, nWrong: nWrong, firstCorrectIsQuestion: true, parameters: builderParams);
                break;

            case ThrowBallsVariation.words:
                builderParams.wordFilters.requireDrawings = true;
                builder = new RandomWordsQuestionBuilder(nPacks, 1, nWrong, firstCorrectIsQuestion: true, parameters: builderParams);
                break;

            case ThrowBallsVariation.lettersinword:
                builder = new LettersInWordQuestionBuilder(nPacks: nPacks, maximumWordLength: 7, nWrong: nWrong, useAllCorrectLetters: true, parameters: builderParams);
                break;
            }

            return(builder);
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.letterFilters.excludeDiacritics = true;
            builderParams.wordFilters.excludeDiacritics   = true;
            builder = new RandomLettersQuestionBuilder(7, 1, parameters: builderParams);

            return(builder);
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 10;
            int nCorrect = 5;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builder = new RandomLettersQuestionBuilder(nPacks, nCorrect, parameters: builderParams);

            return(builder);
        }
        private IQuestionBuilder Setup_SingularDualPlural_Builder()
        {
            SimultaneosQuestions = 3;
            Rounds  = 3;
            Answers = 2;
            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory         = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wordFilters.excludePluralDual = false;

            return(new WordsByFormQuestionBuilder(
                       SimultaneosQuestions * Rounds * 4,
                       builderParams));
        }
        private IQuestionBuilder Setup_WordArticle_Builder()
        {
            SimultaneosQuestions = 2;
            Rounds  = 3;
            Answers = 2;
            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory       = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wordFilters.excludeArticles = false;

            return(new WordsByArticleQuestionBuilder(
                       Answers * Rounds * 3,
                       builderParams));
        }
        private IQuestionBuilder Setup_SunMoonLetter_Builder()
        {
            SimultaneosQuestions = 2;
            Rounds  = 3;
            Answers = 2;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory = Teacher.PackListHistory.RepeatWhenFull;

            return(new LettersBySunMoonQuestionBuilder(
                       SimultaneosQuestions * Rounds * 3,
                       builderParams
                       ));
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 10;
            int nCorrect = 1;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.letterFilters.excludeDiacritics = true;
            builderParams.wordFilters.excludeDiacritics   = true;
            builder = new RandomLettersQuestionBuilder(nPacks, nCorrect, parameters: builderParams);

            return(builder);
        }
示例#9
0
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks            = 10;
            int nMinCommonLetters = 1;
            int nMaxCommonLetters = 1;
            int nWrong            = 5;
            int nWords            = 2;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builder = new CommonLettersInWordQuestionBuilder(nPacks, nMinCommonLetters, nMaxCommonLetters, nWrong, nWords, parameters: builderParams);

            return(builder);
        }
        private IQuestionBuilder Setup_OrderLettersOfWord_Builder()
        {
            SimultaneosQuestions = 1;
            Rounds = 3;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.wordFilters.requireDrawings = true;

            return(new LettersInWordQuestionBuilder(
                       Rounds,
                       2,
                       useAllCorrectLetters: true,
                       parameters: builderParams
                       ));
        }
示例#11
0
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            SetupVariables();

            int nPacks = 7;             // One Extra for tutorial

            nCorrect = 1;
            int nWrong = 4;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.wordFilters.excludeColorWords = true;
            builderParams.wordFilters.requireDrawings   = true;

            switch (Variation)
            {
            case ScannerVariation.OneWord:
                nCorrect = 1;
                nWrong   = 4;
                break;

            case ScannerVariation.MultipleWords:
                if (Difficulty < 0.5f)
                {
                    nCorrect = 3;
                }
                else
                {
                    nCorrect = 5;
                }
                nWrong = 0;
                break;
            }

            builder = new RandomWordsQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);


            if (builder == null)
            {
                throw new System.Exception("No question builder defined for variation " + Variation.ToString());
            }


            return(builder);
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 7; // extra one for the tutorial
            int nCorrect = 1;
            int nWrong   = 0;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.letterFilters.excludeDiacritics_keepMain = true;
            builderParams.letterFilters.excludeLetterVariations    = false;
            builderParams.wordFilters.excludeDiacritics            = false;
            builderParams.wordFilters.excludeLetterVariations      = false;
            builder = new RandomLettersQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);

            return(builder);
        }
        private IQuestionBuilder Setup_LetterShape_Builder()
        {
            SimultaneosQuestions = 1;
            Rounds = 3;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongChoicesHistory   = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongSeverity         = Teacher.SelectionSeverity.MayRepeatIfNotEnough;
            builderParams.useJourneyForWrong    = false;

            return(new RandomLettersQuestionBuilder(
                       SimultaneosQuestions * Rounds, // Total Answers
                       1,                             // CorrectAnswers
                       snag.Increase(3, 6),           // WrongAnswers
                       firstCorrectIsQuestion: true,
                       parameters: builderParams));
        }
        private IQuestionBuilder Setup_MatchLettersToWord_Builder()
        {
            SimultaneosQuestions = 1;
            Rounds = 3;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongChoicesHistory   = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongSeverity         = Teacher.SelectionSeverity.MayRepeatIfNotEnough;
            builderParams.useJourneyForWrong    = false;

            return(new LettersInWordQuestionBuilder(

                       SimultaneosQuestions * Rounds, // Total Answers
                       snag.Decrease(3, 2),           // CorrectAnswers
                       snag.Increase(1, 4),           // WrongAnswers
                       useAllCorrectLetters: false,
                       parameters: builderParams));
        }
        private IQuestionBuilder Setup_SelectPronuncedWord_Builder()
        {
            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongChoicesHistory   = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongSeverity         = Teacher.SelectionSeverity.MayRepeatIfNotEnough;
            builderParams.useJourneyForWrong    = false;
            SimultaneosQuestions = 1;
            Rounds = 3;
            int nCorrect = 1;
            int nWrong   = snag.Increase(2, 4);

            return(new RandomWordsQuestionBuilder(
                       SimultaneosQuestions * Rounds,
                       nCorrect,
                       nWrong,
                       firstCorrectIsQuestion: true,
                       parameters: builderParams));
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks = 10;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case MixedLettersVariation.Alphabet:
                builder = new AlphabetQuestionBuilder(parameters: builderParams);
                break;

            case MixedLettersVariation.Spelling:
                builder = new LettersInWordQuestionBuilder(nPacks, maximumWordLength: 6, useAllCorrectLetters: true, parameters: builderParams);
                break;
            }

            return(builder);
        }
        private IQuestionBuilder Setup_WordsWithLetter_Builder()
        {
            SimultaneosQuestions = 2;
            snag.SetStartingFrom(0.5f);
            Rounds = 3;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongChoicesHistory   = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongSeverity         = Teacher.SelectionSeverity.MayRepeatIfNotEnough;
            builderParams.useJourneyForWrong    = false;

            return(new WordsWithLetterQuestionBuilder(

                       SimultaneosQuestions * Rounds, // Total Answers
                       1,                             // Correct Answers
                       snag.Increase(1, 2),           // Wrong Answers
                       parameters: builderParams
                       ));
        }
示例#18
0
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case ReadingGameVariation.AlphabetSong:
                builder = new EmptyQuestionBuilder();
                break;

            case ReadingGameVariation.ReadAndAnswer:
                builderParams.wordFilters.excludeColorWords       = true;
                builderParams.wordFilters.requireDrawings         = true;
                builderParams.phraseFilters.requireAnswersOrWords = true;
                builder = new WordsInPhraseQuestionBuilder(nPacks: 10, nCorrect: 1, nWrong: 6, usePhraseAnswersIfFound: true, parameters: builderParams);
                break;
            }
            return(builder);
        }
        private IQuestionBuilder Setup_CompleteWord_Builder()
        {
            SimultaneosQuestions = 1;
            Rounds = 3;

            var builderParams = new Teacher.QuestionBuilderParameters();

            builderParams.correctChoicesHistory       = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongChoicesHistory         = Teacher.PackListHistory.RepeatWhenFull;
            builderParams.wrongSeverity               = Teacher.SelectionSeverity.MayRepeatIfNotEnough;
            builderParams.useJourneyForWrong          = true;
            builderParams.wordFilters.requireDrawings = true;

            return(new LettersInWordQuestionBuilder(

                       SimultaneosQuestions * Rounds, // Total Answers
                       1,                             // Always one!
                       snag.Increase(3, 5),           // WrongAnswers
                       useAllCorrectLetters: false,
                       parameters: builderParams));
        }
示例#20
0
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 10;
            int nCorrect = 4;
            int nWrong   = 4;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case FastCrowdVariation.Alphabet:
                builder = new AlphabetQuestionBuilder();
                break;

            case FastCrowdVariation.Counting:
                builder = new OrderedWordsQuestionBuilder(Db.WordDataCategory.NumberOrdinal);
                break;

            case FastCrowdVariation.Letter:
                builder = new RandomLettersQuestionBuilder(nPacks, 1, nWrong, firstCorrectIsQuestion: true);
                break;

            case FastCrowdVariation.Spelling:
                builderParams.wordFilters.excludeColorWords = true;
                builderParams.wordFilters.requireDrawings   = true;
                builder = new LettersInWordQuestionBuilder(nPacks, nWrong: nWrong, useAllCorrectLetters: true, parameters: builderParams);
                break;

            case FastCrowdVariation.Words:
                builderParams.wordFilters.excludeColorWords = true;
                builderParams.wordFilters.requireDrawings   = true;
                builder = new RandomWordsQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);
                break;
            }

            return(builder);
        }
        public IQuestionBuilder SetupBuilder()
        {
            IQuestionBuilder builder = null;

            int nPacks   = 10;
            int nCorrect = 1;
            int nWrong   = 5;

            var builderParams = new Teacher.QuestionBuilderParameters();

            switch (Variation)
            {
            case MissingLetterVariation.MissingLetter:
                builder = new LettersInWordQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);
                break;

            case MissingLetterVariation.MissingWord:
                builderParams.phraseFilters.requireWords           = true;
                builderParams.phraseFilters.requireAtLeastTwoWords = true;
                builder = new WordsInPhraseQuestionBuilder(nPacks, nCorrect, nWrong, parameters: builderParams);
                break;
            }
            return(builder);
        }