コード例 #1
0
        async Task Load(int id)
        {
            // Get a test from the API
            ABTestData aBTestData = await TJBarnesService.GetHttpClient()
                                    .GetFromJsonAsync <ABTestData>("api/abtests/" + id.ToString());

            // Use the Deserializer method of the JsonSerializer class (in the System.Text.Json namespace) to create
            // a BlowSetCore object for each of A and B
            BlowSetCore blowSetCoreA = JsonSerializer.Deserialize <BlowSetCore>(aBTestData.ABTestSpecA);
            BlowSetCore blowSetCoreB = JsonSerializer.Deserialize <BlowSetCore>(aBTestData.ABTestSpecB);

            testSpec.AHasErrors = blowSetCoreA.HasErrors;

            // Create a BlowSet object from the BlowSetCore object for A
            blowSetA = new BlowSet(blowSetCoreA.Stage, blowSetCoreA.NumRows, blowSetCoreA.TenorWeight,
                                   blowSetCoreA.ErrorType, blowSetCoreA.HasErrors);

            // Use an audioIdSuffix of "b" for this blowset
            blowSetA.LoadBlows(blowSetCoreA, "a");

            blowSetA.SetUnstruck();

            // Create a BlowSet object from the BlowSetCore object for B
            blowSetB = new BlowSet(blowSetCoreB.Stage, blowSetCoreB.NumRows, blowSetCoreB.TenorWeight,
                                   blowSetCoreB.ErrorType, blowSetCoreB.HasErrors);

            // Use an audioIdSuffix of "b" for this blowset
            blowSetB.LoadBlows(blowSetCoreB, "b");

            blowSetB.SetUnstruck();

            // Update drop down boxes on screen
            // Use BlowSetA - by definition the following properties for BlowSetA and BlowSetB will be the same
            testSpec.Stage       = blowSetA.Stage;
            testSpec.TenorWeight = blowSetA.TenorWeight;
            testSpec.ErrorType   = blowSetA.ErrorType;

            // Set up test spec-dependent elements of the screen object
            int baseGap = BaseGaps.BaseGap(testSpec.Stage, testSpec.TenorWeight, 1);

            testSpec.BaseGap = baseGap;

            // Set the timing for the animation (when not showing the bells)
            screenA.AnimationDuration = blowSetA.Blows.Last().GapCumulative + 1000;
            screenB.AnimationDuration = blowSetB.Blows.Last().GapCumulative + 1000;
            testSpec.ResultEntered    = false;

            testSpec.ShowGaps = false;
            StateHasChanged();
        }
コード例 #2
0
        async Task Load(int id)
        {
            // Get a test from the API
            GapTestData gapTestData = await TJBarnesService.GetHttpClient().
                                      GetFromJsonAsync <GapTestData>("api/gaptests/" + id.ToString());

            // Use the Deserializer method of the JsonSerializer class (in the System.Text.Json namespace) to create
            // a BlowSetCore object
            BlowSetCore blowSetCore = JsonSerializer.Deserialize <BlowSetCore>(gapTestData.GapTestSpec);

            // Now create a BlowSet object from the BlowSetCore object
            blowSet = new BlowSet(blowSetCore.Stage, blowSetCore.NumRows, blowSetCore.TenorWeight,
                                  blowSetCore.ErrorType, true);

            // No need for an audio suffix in a Gap test (this is used to distinguish A and B in an A/B test)
            blowSet.LoadBlows(blowSetCore, string.Empty);
            blowSet.SetUnstruck();

            // Update drop down boxes on screen
            testSpec.Stage       = blowSet.Stage;
            testSpec.TenorWeight = blowSet.TenorWeight;
            testSpec.NumRows     = blowSet.NumRows;

            // Set up test spec-dependent elements of the screen object
            int baseGap = BaseGaps.BaseGap(testSpec.Stage, testSpec.TenorWeight, 1);

            testSpec.BaseGap = baseGap;
            testSpec.GapMin  = 20;

            // If test bell is 1st's place of a handstroke row, need to adjust GapMax to have a higher value
            // because of the handstroke gap
            if (blowSet.Blows.Last().IsHandstroke == true && blowSet.Blows.Last().Place == 1)
            {
                testSpec.GapMax = Convert.ToInt32(Math.Round(((double)testSpec.BaseGap * 3) / 50)) * 50;
            }
            else
            {
                testSpec.GapMax = Convert.ToInt32(Math.Round(((double)baseGap * 2) / 50)) * 50;
            }

            testSpec.ShowGaps = false;
            StateHasChanged();
        }
コード例 #3
0
        void Create()
        {
            Block testBlock = new Block(testSpec.Stage, testSpec.NumRows);

            testBlock.CreateRandomBlock();

            // Set place to be the test place
            int testPlace;

            testPlace = testSpec.Stage + (testSpec.Stage % 2);

            if (testSpec.TestBellLoc != 1)
            {
                Random rand = new Random();
                testPlace = rand.Next(1, testPlace + 1);
            }

            blowSet = new BlowSet(testSpec.Stage, testSpec.NumRows, testSpec.TenorWeight, testSpec.ErrorType, true);

            // No need for an audio suffix in a Gap test (this is used to distinguish A and B in an A/B test)
            blowSet.PopulateBlows(testBlock, testPlace, string.Empty);
            blowSet.CreateRandomSpacing(testSpec.ErrorSize, Constants.Rounding);
            blowSet.SetUnstruck();

            // Set up test spec-dependent elements of the screen object
            // When practicing in a Gap Test, gaps are rounded to the nearest 10ms so that bells will align
            // if zero gap error is selected
            int baseGap = BaseGaps.BaseGap(testSpec.Stage, testSpec.TenorWeight, 10);

            testSpec.BaseGap = baseGap;
            testSpec.GapMin  = 20;

            // If test bell is 1st's place of a handstroke row, need to adjust GapMax to have a higher value
            // because of the handstroke gap
            if (testSpec.NumRows % 2 == 1 && testPlace == 1)
            {
                testSpec.GapMax = Convert.ToInt32(Math.Round(((double)testSpec.BaseGap * 3) / 50)) * 50;
            }
            else
            {
                testSpec.GapMax = Convert.ToInt32(Math.Round(((double)baseGap * 2) / 50)) * 50;
            }
        }
コード例 #4
0
        public void CreateEvenSpacing(int gapRound)
        {
            int gap;
            int gapCumulativeRow = 0;
            int gapCumulative    = 0;

            int baseGap = BaseGaps.BaseGap(Stage, TenorWeight, gapRound);

            foreach (Blow blow in Blows)
            {
                // if 1st's place and handstroke, double the gap
                if (blow.Place == 1 && blow.IsHandstroke == true)
                {
                    gap = baseGap * 2;
                }
                else
                {
                    gap = baseGap;
                }

                if (blow.Place == 1)
                {
                    gapCumulativeRow = gap;
                }
                else
                {
                    gapCumulativeRow += gap;
                }

                gapCumulative += gap;

                blow.Gap = gap;
                blow.GapCumulativeRow = gapCumulativeRow;
                blow.GapCumulative    = gapCumulative;
                blow.GapStr           = gap.ToString();
            }
        }
コード例 #5
0
        public void CreateRandomSpacing(int errorSize, int gapRound)
        {
            int gap;
            int gapCumulativeRow = 0;
            int gapCumulative    = 0;

            // Although we round the resulting gap later, we still need to round basegap because
            // otherwise we won't get even striking when errorSize is zero
            // This is because (baseGap * 2) might round to something other than (baseGap rounded) * 2
            // and also because gapReversion will affect whether an indivdiual gap is rounded up or down
            int baseGap = BaseGaps.BaseGap(Stage, TenorWeight, gapRound);

            int baseGapCumulative = 0;
            int gapReversion      = 0;

            Random rand = new Random();

            foreach (Blow blow in Blows)
            {
                // if 1st's place and handstroke, double the gap
                if (blow.Place == 1 && blow.IsHandstroke == true)
                {
                    gap = rand.Next((baseGap * 2) - errorSize, (baseGap * 2) + (errorSize + 1));
                    baseGapCumulative += (baseGap * 2);
                }
                else
                {
                    gap = rand.Next(baseGap - errorSize, baseGap + (errorSize + 1));
                    baseGapCumulative += baseGap;
                }

                if (gapReversion < 0)
                {
                    gap += rand.Next(gapReversion, 1);
                }
                else if (gapReversion > 0)
                {
                    gap += rand.Next(0, gapReversion + 1);
                }

                if (gapRound > 1)
                {
                    gap = Convert.ToInt32((double)gap / gapRound) * gapRound;
                }

                if (blow.Place == 1)
                {
                    gapCumulativeRow = gap;
                }
                else
                {
                    gapCumulativeRow += gap;
                }

                gapCumulative += gap;

                gapReversion = baseGapCumulative - gapCumulative;

                blow.Gap = gap;
                blow.GapCumulativeRow = gapCumulativeRow;
                blow.GapCumulative    = gapCumulative;
                blow.GapStr           = gap.ToString();
            }
        }
コード例 #6
0
        void Create()
        {
            // Choose whether A or B will have the errors
            Random rand = new Random();

            testSpec.AHasErrors = rand.Next(0, 2) == 0;

            // Create the test block
            Block testBlock = new Block(testSpec.Stage, testSpec.NumRows);

            testBlock.CreateRandomBlock();

            blowSetA = new BlowSet(testSpec.Stage, testSpec.NumRows, testSpec.TenorWeight,
                                   testSpec.ErrorType, testSpec.AHasErrors);
            blowSetA.PopulateBlows(testBlock, testSpec.TestBellLoc, "a");

            // No rounding in an A/B test
            blowSetA.CreateEvenSpacing(1);
            blowSetA.SetUnstruck();

            blowSetB = new BlowSet(testSpec.Stage, testSpec.NumRows, testSpec.TenorWeight,
                                   testSpec.ErrorType, !testSpec.AHasErrors);
            blowSetB.PopulateBlows(testBlock, testSpec.TestBellLoc, "b");

            // No rounding in an A/B test
            blowSetB.CreateEvenSpacing(1);
            blowSetB.SetUnstruck();

            if (testSpec.AHasErrors == true)
            {
                if (testSpec.ErrorType == 1)
                {
                    blowSetA.CreateStrikingError(testSpec.ErrorSize);
                }
                else
                {
                    blowSetA.CreateCompassError(testSpec.ErrorSize);
                }
            }
            else
            {
                if (testSpec.ErrorType == 1)
                {
                    blowSetB.CreateStrikingError(testSpec.ErrorSize);
                }
                else
                {
                    blowSetB.CreateCompassError(testSpec.ErrorSize);
                }
            }

            // Set up test spec-dependent elements of the screen object
            int baseGap = BaseGaps.BaseGap(testSpec.Stage, testSpec.TenorWeight, 1);

            testSpec.BaseGap = baseGap;

            // Set the timing for the animation (when not showing the bells)
            screenA.AnimationDuration = blowSetA.Blows.Last().GapCumulative + 1000;
            screenB.AnimationDuration = blowSetB.Blows.Last().GapCumulative + 1000;
            testSpec.ResultEntered    = false;

            testSpec.ShowGaps = false;
        }