rt300@8: //
rt300@14: //  SequenceGenerator.mm
rt300@8: //  riftathon
rt300@8: //
rt300@14: //  Created by Robert Tubb on 21/10/2014.
rt300@8: //
rt300@8: //
rt300@8: 
rt300@8: #include "SequenceController.h"
rt300@27: AnimStep::AnimStep(){
rt300@27:     type = PREVIEW_NEUTRAL_COUNT;
rt300@27:     presetIndex = -1;
rt300@27:     seqNumber = -1;
rt300@43:     runNumber = 0;
rt300@27:     whichInSequence = -1;
rt300@27:     
rt300@27:     tempo = MIN_TEMPO;
rt300@27:     
rt300@27:     isLastOfSeq = false;
rt300@27:     isLastOfRun = false;
rt300@27:     isLastOfAll = false;
rt300@27:     
rt300@27:     showsGuides = false;
rt300@31:     showsIcons = true;
rt300@31:     showsResultsAtEnd = false;
rt300@35:     difficulty = 0;
rt300@36:     setTimeFromTempo();
rt300@43:     totalLengthOfSeq = 0;
rt300@27: }
rt300@31: 
rt300@31: void AnimStep::saveResult(TrainingTestResult aresult){
rt300@31:     result = aresult;
rt300@31: }
rt300@31: 
rt300@21: Step::Step(){
rt300@21:     type = COUNT_IN;
rt300@21:     
rt300@21:     showsTargetIcon = false;
rt300@21:     showsControlSettings = false;
rt300@21:     showsControlGuides = false;
rt300@21:     showsMatchResults = false;
rt300@22:     hidesSliders = true;
rt300@21:     isPreview = false;
rt300@21:     
rt300@21:     allowsCandidateControl = false;
rt300@21:     playsTarget = false;
rt300@21:     playsCandidate = false;
rt300@21:     
rt300@22:     showsCountDown = true;
rt300@21:     
rt300@21:     isLastOfSeq = false;
rt300@21:     isLastOfRun = false;
rt300@21:     isLastOfAll = false;
rt300@21:     presetIndex = -1;
rt300@21:     seqNumber = -1;
rt300@21:     runNumber = -1;
rt300@21:     
rt300@21:     tempo = MIN_TEMPO;
rt300@21: }
rt300@22: void Step::setAsBlankCounter(){
rt300@22:     type = COUNT_IN;
rt300@22:     showsTargetIcon = false;
rt300@22:     showsControlSettings = false;
rt300@22:     showsControlGuides = false;
rt300@22:     showsMatchResults = false;
rt300@22:     hidesSliders = true;
rt300@22:     isPreview = false;
rt300@22:     
rt300@22:     allowsCandidateControl = false;
rt300@22:     playsTarget = false;
rt300@22:     playsCandidate = false;
rt300@22:     showsCountDown = true;
rt300@22:     
rt300@22: }
rt300@22: void Step::setAsPreviewPreparer(){
rt300@22:     type = PREVIEW_PREPARER;
rt300@21:     showsTargetIcon = true;
rt300@22:     showsControlSettings = false;
rt300@27:     showsControlGuides = true;
rt300@27:     
rt300@21:     showsMatchResults = false;
rt300@22:     hidesSliders = true;
rt300@21:     isPreview = true;
rt300@21:     
rt300@26:     allowsCandidateControl = true;
rt300@21:     playsTarget = true;
rt300@21:     playsCandidate = false;
rt300@22:     showsCountDown = true;
rt300@21: }
rt300@22: 
rt300@21: void Step::setAsPreviewPlayer(){
rt300@22:     type = PREVIEW_DISPLAYER;
rt300@21:     showsTargetIcon = true;
rt300@26:     showsControlSettings = false;
rt300@26:     showsControlGuides = true;
rt300@21:     showsMatchResults = false;
rt300@22:     hidesSliders = false;
rt300@22:     
rt300@21:     isPreview = true;
rt300@21:     
rt300@26:     allowsCandidateControl = true;
rt300@21:     playsTarget = true;
rt300@21:     playsCandidate = false;
rt300@21:     
rt300@22:     showsCountDown = false;
rt300@21: }
rt300@22: 
rt300@21: void Step::setAsMatchingPreparer(){
rt300@22:     // just a count down
rt300@22:     type = MATCHING_PREPARER;
rt300@22:     showsTargetIcon = true;
rt300@22:     showsControlSettings = false;
rt300@22:     showsControlGuides = false;
rt300@22:     showsMatchResults = false;
rt300@22:     hidesSliders = true;
rt300@22:     
rt300@22:     isPreview = false;
rt300@22:     
rt300@26:     allowsCandidateControl = true;
rt300@22:     playsTarget = true;
rt300@22:     playsCandidate = false;
rt300@22:     
rt300@22:     showsCountDown = true;
rt300@22: }
rt300@22: void Step::setAsMatchingInteraction(){
rt300@21:     type = MATCHING_INTERACTION;
rt300@21:     showsTargetIcon = true;
rt300@21:     showsControlSettings = false;
rt300@23:     showsControlGuides = true;
rt300@21:     showsMatchResults = false;
rt300@22:     hidesSliders = false;
rt300@21:     isPreview = false;
rt300@21:     
rt300@21:     allowsCandidateControl = true;
rt300@21:     playsTarget = false;
rt300@22:     playsCandidate = false; // ??
rt300@21:     
rt300@22:     showsCountDown = false;
rt300@21: }
rt300@22: void Step::setAsMatchingFeedback(){
rt300@22:     type = MATCHING_INTERACTION;
rt300@22:     showsTargetIcon = false;
rt300@21:     showsControlSettings = false;
rt300@22:     showsControlGuides = false;
rt300@22:     showsMatchResults = true;
rt300@22:     hidesSliders = true;
rt300@21:     isPreview = false;
rt300@21:     
rt300@21:     allowsCandidateControl = false;
rt300@21:     playsTarget = false;
rt300@22:     playsCandidate = true; // ??
rt300@21:     
rt300@22:     showsCountDown = false;
rt300@21: }
rt300@21: 
rt300@21: //=================================================================
rt300@21: //=================================================================
rt300@21: //=================================================================
rt300@21: 
rt300@21: SequenceController::SequenceController(){
rt300@51:     int tie[] = {
rt300@44:         2500,
rt300@44:         1944,
rt300@44:         1590,
rt300@44:         1346,
rt300@44:         1166,
rt300@44:         1029,
rt300@44:         921,
rt300@44:         833,
rt300@44:         760,
rt300@44:         700,
rt300@44:         648,
rt300@44:         603,
rt300@44:         564,
rt300@44:         530,
rt300@44:         500
rt300@43:     };
rt300@51:     
rt300@51:     int tih[] = {
rt300@51:         800,
rt300@51:         700,
rt300@51:         608,
rt300@51:         538,
rt300@51:         482,
rt300@51:         437,
rt300@51:         400,
rt300@51:         368,
rt300@51:         341,
rt300@51:         327,
rt300@51:         311,
rt300@51:         296,
rt300@51:         283,
rt300@51:         271,
rt300@51:         260,
rt300@51:         250,
rt300@51:         243,
rt300@51:         236,
rt300@51:         230,
rt300@51:         225,
rt300@51:         220,
rt300@51:         215,
rt300@51:         210,
rt300@51:         205,
rt300@51:         200
rt300@51:         
rt300@51:     };
rt300@51: 
rt300@51:     
rt300@51: 
rt300@44:     for(int i = 0; i < NUM_TEMPO_STEPS; i++){
rt300@51:         timeIntervalsHard.push_back(tie[i]);
rt300@43:     }
rt300@44: 
rt300@43:     
rt300@43:     currentRunNumber = 0; // actually goes from 1 0 is pre-start
rt300@43:     
rt300@32: };
rt300@32: //-------------------------------------------------------------------
rt300@47: void SequenceController::init(bool asoundOnlyMode, controlPanelType whichInterfaceAreWeUsing, bool ademoMode){
rt300@47:     demoMode = ademoMode;
rt300@32:     soundOnlyMode = asoundOnlyMode;
rt300@43:     panelType = whichInterfaceAreWeUsing;
rt300@21:     tempoInc = float(MAX_TEMPO - MIN_TEMPO) / float(NUM_TEMPO_STEPS);
rt300@36:     timeInc = (MAX_TIME - MIN_TIME) / NUM_TEMPO_STEPS;
rt300@43:     
rt300@47:     if (!demoMode){
rt300@50:         generateSteps12();
rt300@43:     }else{
rt300@45:         generateTestSequence(1);
rt300@45:         generateTestSequence(2);
rt300@49:         generateTestSequence(3);
rt300@43:     }
rt300@43:     
rt300@21:     setToStart();
rt300@43:     
rt300@21: };
rt300@48: 
rt300@48: void SequenceController::clearAll(){
rt300@48:     steps.clear();
rt300@48:     totNumRuns = 0;
rt300@48:     currentRunNumber = 0;
rt300@48:     currentStep = steps.begin();
rt300@48:     
rt300@48: }
rt300@32: //-------------------------------------------------------------------
rt300@27: AnimStep SequenceController::getNextStep(){
rt300@21:     
rt300@21:     currentStep++;
rt300@21:     if ((*currentStep).isLastOfRun){
rt300@21:         // uh
rt300@21:     }
rt300@21:     if ((*currentStep).isLastOfSeq){
rt300@21:         
rt300@21:     }
rt300@21:     return (*currentStep);
rt300@21:     
rt300@21: };
rt300@27: //-------------------------------------------------------------------
rt300@21: void SequenceController::setToStart(){
rt300@21:     currentStep = steps.begin();
rt300@43:     currentRunNumber = (*currentStep).runNumber;
rt300@43: }
rt300@43: //-------------------------------------------------------------------
rt300@43: void SequenceController::skipRun(){
rt300@43:     // loop thru steps until next run reached
rt300@47:     if ( (*currentStep).isLastOfAll || (*currentStep).runNumber >= totNumRuns){
rt300@50:         setToStart();
rt300@44:         return;
rt300@44:     }
rt300@44:     currentStep++; // IGNORE CURRENT STEP (LAST OF OLD RUN)
rt300@44:     
rt300@43:     bool nextRunReached = false;
rt300@43:     
rt300@43:     while (!nextRunReached){
rt300@43:         currentStep++;
rt300@44:         if ( (*currentStep).isLastOfAll){
rt300@50:             setToStart();
rt300@44:             return;
rt300@44:         }
rt300@43:         if ((*currentStep).runNumber != currentRunNumber && (*currentStep).runNumber != 0){
rt300@43:             nextRunReached = true;
rt300@43:             currentRunNumber = (*currentStep).runNumber;
rt300@43:         }
rt300@43:     }
rt300@21: }
rt300@27: //-------------------------------------------------------------------
rt300@21: void SequenceController::stepForward(){
rt300@21:     currentStep++;
rt300@21: };
rt300@27: //-------------------------------------------------------------------
rt300@43: float SequenceController::getStartIntervalTime(){
rt300@43:     float t =  timeIntervalsHard[0];
rt300@43:     if (panelType == ALL_SLIDERS){
rt300@44:         t = SLIDER_SLOW_FACTOR*t;
rt300@43:     }
rt300@47:     if(demoMode){
rt300@47:         t = 2*t;
rt300@47:     }
rt300@43:     return t;
rt300@21: }
rt300@27: //-------------------------------------------------------------------
rt300@21: void SequenceController::generateSteps(){
rt300@21:     srand (time(NULL));
rt300@21:     
rt300@43:     int run = 1;
rt300@21:     
rt300@21:     
rt300@21:     
rt300@21:     for(int numInSequence = MIN_TARGETS_IN_SEQUENCE; numInSequence <= MAX_TARGETS_IN_SEQUENCE; numInSequence++){
rt300@36:         
rt300@36:         for(int rep = 0; rep < NUM_REPETITIONS_AT_LEVEL; rep++){
rt300@43:             
rt300@43:             generateCountIn(1,run);
rt300@43:             
rt300@43:             if (soundOnlyMode){
rt300@43:                 generateASoundOnlyRun(run, numInSequence);
rt300@43:             }else {
rt300@43:                 generateRun(run, numInSequence);
rt300@43:             }
rt300@43:             steps.back().isLastOfRun = true;
rt300@43:             run++;
rt300@43:             cout << "-generate run finished-" << endl;
rt300@36:         }
rt300@21:     }
rt300@44:     totNumRuns = run-1;
rt300@21:     steps.back().isLastOfAll = true;
rt300@21: };
rt300@50: //-------------------------------------------------------------------
rt300@50: void SequenceController::generateSteps12(){
rt300@50:     srand (time(NULL));
rt300@50:     
rt300@50:     int run = 1;
rt300@50:     
rt300@50:     for(int rep = 0; rep < 4; rep++){
rt300@50:     
rt300@50:     for(int numInSequence = 1; numInSequence <= 3; numInSequence++){
rt300@50: 
rt300@50:             generateCountIn(1,run);
rt300@50: 
rt300@50:             generateRun(run, numInSequence);
rt300@50: 
rt300@50:             steps.back().isLastOfRun = true;
rt300@50:             run++;
rt300@50:             cout << "-generate run finished-" << endl;
rt300@50:         }
rt300@50:     }
rt300@50:     totNumRuns = run-1;
rt300@50:     steps.back().isLastOfAll = true;
rt300@50: };
rt300@27: 
rt300@27: //-------------------------------------------------------------------
rt300@45: void SequenceController::generateTestSequence(int run){
rt300@43:     // just make something simple to check sanity
rt300@50:     generateCountIn(1,run);
rt300@43:     
rt300@49:     vector<int> seq = randomSequence(run);
rt300@43:     
rt300@43:     // first we have a preparation count in
rt300@43:     AnimStep nextStep;
rt300@43:     nextStep.presetIndex = -1; // minus one means "blank"
rt300@47:     nextStep.runNumber = run;
rt300@43:     nextStep.seqNumber = 1;
rt300@43:     nextStep.whichInSequence = 0;
rt300@43:     //nextStep.tempo = curTempo;
rt300@43:     nextStep.tempoLevel = 0;
rt300@43:     //        nextStep.setTimeFromTempo();
rt300@47:     nextStep.timeAllowedMs = getStartIntervalTime();
rt300@43:     nextStep.setTempoFromTime();
rt300@43:     nextStep.showsGuides = true;
rt300@43:     nextStep.difficulty = 0;
rt300@43:     nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
rt300@43:     nextStep.showsResultsAtEnd = false;
rt300@43:     
rt300@45:     steps.push_back(nextStep);
rt300@43:     
rt300@43:     makePreview(seq, 0, nextStep);
rt300@27: 
rt300@43:     makeGuidedSequence(seq, 0, nextStep);
rt300@47:     makeGuidedSequence(seq, 0, nextStep);
rt300@43: 
rt300@43:     makeMatchingSequence(seq, 0, nextStep);
rt300@47:     makeMatchingSequence(seq, 0, nextStep);
rt300@47:     nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
rt300@47:     steps.push_back(nextStep);
rt300@47:     
rt300@47:     makePreview(seq, 0, nextStep);
rt300@47:     
rt300@47:     makeGuidedSequence(seq, 0, nextStep);
rt300@47:     makeGuidedSequence(seq, 0, nextStep);
rt300@47:     
rt300@47:     makeMatchingSequence(seq, 0, nextStep);
rt300@47:     makeMatchingSequence(seq, 0, nextStep);
rt300@50:     nextStep.type = AnimStep::MATCHING_LAST;
rt300@47:     steps.push_back(nextStep);
rt300@43:     
rt300@45:     totNumRuns = run;
rt300@45:     steps.back().isLastOfRun = true;
rt300@43:     
rt300@43: }
rt300@43: //-------------------------------------------------------------------
rt300@43: 
rt300@43: 
rt300@43: void SequenceController::generateCountIn(int countInLength, int runNumber){
rt300@27:     AnimStep countStep;
rt300@21:     for (int i = 0; i < countInLength; i++){
rt300@27:         countStep.whichInSequence = countInLength - i + 1;
rt300@27:         countStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
rt300@36:         countStep.showsResultsAtEnd = false;
rt300@43:         countStep.runNumber = runNumber;
rt300@43:         countStep.timeAllowedMs = getStartIntervalTime();
rt300@43:         countStep.setTempoFromTime();
rt300@21:         steps.push_back(countStep);
rt300@21:         
rt300@21:     }
rt300@21: };
rt300@27: 
rt300@27: //-------------------------------------------------------------------
rt300@27: 
rt300@27: 
rt300@27: vector<int> SequenceController::randomSequence(int numInSequence){
rt300@27:     vector<int> stepPresetIndices;
rt300@27:     // get some random ints
rt300@27:     for(int n=0; n < numInSequence; n++){
rt300@27:         int nextPreset = getRandomButNot(NUM_PRESETS,stepPresetIndices);
rt300@27:         stepPresetIndices.push_back(nextPreset);
rt300@27:         cout << nextPreset << ",";
rt300@27:     }
rt300@27:     
rt300@27:     return stepPresetIndices;
rt300@27: }
rt300@27: 
rt300@32: vector<int> SequenceController::nonRandomSequence(int numInSequence){
rt300@32:     vector<int> stepPresetIndices;
rt300@43:     // 1,2,3,4 you know the score
rt300@32:     for(int n=0; n < numInSequence; n++){
rt300@32:         int nextPreset = n;
rt300@32:         stepPresetIndices.push_back(nextPreset);
rt300@32:         cout << nextPreset << ",";
rt300@32:     }
rt300@32:     
rt300@32:     return stepPresetIndices;
rt300@32: }
rt300@34: //-------------------------------------------------------------------
rt300@32: 
rt300@41: void SequenceController::generateRun(int run, int numInSequence){
rt300@34:     float curTempo = MIN_TEMPO;
rt300@34:     int seqNo = 0;
rt300@34:     AnimStep nextStep;
rt300@34:     for(int tempoLevel = 0; tempoLevel < NUM_TEMPO_STEPS; tempoLevel++){
rt300@34:         
rt300@34:         
rt300@34:         
rt300@34:         // first we have a preparation count in
rt300@34:         nextStep.presetIndex = -1; // minus one means "blank"
rt300@34:         nextStep.runNumber = run;
rt300@34:         nextStep.seqNumber = seqNo;
rt300@34:         nextStep.whichInSequence = 0;
rt300@43:         //nextStep.tempo = curTempo;
rt300@36:         nextStep.tempoLevel = tempoLevel;
rt300@43: //        nextStep.setTimeFromTempo();
rt300@43:         nextStep.timeAllowedMs = timeIntervalsHard[tempoLevel];
rt300@43:         if (panelType == ALL_SLIDERS){
rt300@44:             nextStep.timeAllowedMs = SLIDER_SLOW_FACTOR*nextStep.timeAllowedMs;
rt300@43:         }
rt300@43:         nextStep.setTempoFromTime();
rt300@34:         nextStep.showsGuides = true;
rt300@35:         nextStep.difficulty = 0;
rt300@34:         nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
rt300@34:         nextStep.showsResultsAtEnd = false;
rt300@41:         
rt300@41:         //nextStep = makeFirstCountIn();
rt300@34:         steps.push_back(nextStep);
rt300@44: 
rt300@44:             // two bar coun tin
rt300@44:         steps.push_back(nextStep);
rt300@44: 
rt300@39:         
rt300@39:         
rt300@34:         // generate a sequence of random preset indices
rt300@34:         vector<int> stepPresetIndices = randomSequence(numInSequence);
rt300@34:         nextStep.thisSequence = stepPresetIndices;
rt300@43:         nextStep.totalLengthOfSeq = numInSequence;
rt300@41:         makePreview(stepPresetIndices, run, nextStep);
rt300@34:         
rt300@41:         // make GUIDED sequence (1 and 2)
rt300@41:         makeGuidedSequence(stepPresetIndices, run, nextStep);
rt300@41:         makeGuidedSequence(stepPresetIndices, run, nextStep);
rt300@34:         
rt300@41:         // make matching sequence without icon seq help
rt300@41:         makeMatchingSequence(stepPresetIndices, run, nextStep);
rt300@41:         makeMatchingSequence(stepPresetIndices, run, nextStep);
rt300@34:         
rt300@34:         steps.back().isLastOfSeq = true;
rt300@41:         if(numInSequence == 1){
rt300@44:             curTempo += tempoInc; // make no 1 easier!!!??? will mess up time points
rt300@41:         }else{
rt300@41:             curTempo += tempoInc;
rt300@41:         }
rt300@34:         seqNo++;
rt300@34:         cout << endl;
rt300@34:         
rt300@34:     }
rt300@43: 
rt300@34:     // ANIM nextStep.setAsBlankCounter();
rt300@34:     nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
rt300@34:     steps.push_back(nextStep);
rt300@34:     
rt300@34: }
rt300@41: void SequenceController::makePreview(vector<int> stepPresetIndices, int run, AnimStep& nextStep){
rt300@41:     
rt300@41:     // MAKE PREVIEW
rt300@41:     int n = 1;
rt300@41:     for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@41:         // put loader
rt300@41:         
rt300@41:         nextStep.presetIndex = *si;
rt300@41:         nextStep.runNumber = run;
rt300@41:         nextStep.whichInSequence = n;
rt300@42:         if (soundOnlyMode){
rt300@42:             nextStep.showsGuides = false;
rt300@42:             nextStep.showsIcons = false ;
rt300@42:         }else{
rt300@42:             nextStep.showsGuides = true;
rt300@42:             nextStep.showsIcons = true;
rt300@42:         }
rt300@41:         nextStep.showsResultsAtEnd = false;
rt300@41:         nextStep.type = AnimStep::PREVIEW_MOVE;
rt300@41:         steps.push_back(nextStep);
rt300@41:         
rt300@41:         n++;
rt300@41:     }
rt300@41:     
rt300@41:     // move back to neutral
rt300@41:     nextStep.presetIndex = -1;
rt300@41:     nextStep.type = AnimStep::PREVIEW_LAST;
rt300@41:     nextStep.whichInSequence = 0;
rt300@41:     nextStep.difficulty = 0;
rt300@41:     nextStep.showsResultsAtEnd = true;
rt300@41:     steps.push_back(nextStep);
rt300@41: }
rt300@41: void SequenceController::makeGuidedSequence(vector<int> stepPresetIndices, int run, AnimStep& nextStep){
rt300@41:     int n = 1;
rt300@41:     for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@41:         // put loader
rt300@41:         nextStep.difficulty = 1;
rt300@41:         nextStep.presetIndex = *si;
rt300@41:         nextStep.runNumber = run;
rt300@41:         nextStep.whichInSequence = n;
rt300@41:         nextStep.showsGuides = true;
rt300@41:         nextStep.showsIcons = true;
rt300@41:         nextStep.showsResultsAtEnd = true;
rt300@41:         nextStep.type = AnimStep::MATCHING_MOVE;
rt300@41:         steps.push_back(nextStep);
rt300@41:         
rt300@41:         if (SPACER_BARS){
rt300@41:             nextStep.type = AnimStep::MATCHING_LAST;
rt300@41:             steps.push_back(nextStep);
rt300@41:         }
rt300@41:         n++;
rt300@41:     }
rt300@41:     // move back to neutral
rt300@41:     nextStep.presetIndex = -1;
rt300@41:     nextStep.type = AnimStep::MATCHING_LAST;
rt300@41:     nextStep.showsGuides = true;
rt300@41:     nextStep.showsIcons = true;
rt300@41:     nextStep.whichInSequence = END_NEUTRAL_MATCH;
rt300@41:     nextStep.difficulty = 0;
rt300@41:     nextStep.showsResultsAtEnd = true;
rt300@41:     steps.push_back(nextStep);
rt300@41: }
rt300@41: void SequenceController::makeMatchingSequence(vector<int> stepPresetIndices, int run, AnimStep& nextStep){
rt300@41:     int n = 1;
rt300@41:     for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@41:         // put loader
rt300@42:         if(soundOnlyMode){
rt300@42:             nextStep.difficulty = 3;
rt300@42:         }else{
rt300@42:             nextStep.difficulty = 2;
rt300@42:         }
rt300@41:         nextStep.presetIndex = *si;
rt300@41:         nextStep.runNumber = run;
rt300@41:         nextStep.whichInSequence = n;
rt300@41:         nextStep.showsGuides = false;
rt300@41:         nextStep.showsIcons = false;
rt300@41:         nextStep.showsResultsAtEnd = true;
rt300@41:         nextStep.type = AnimStep::MATCHING_MOVE;
rt300@41:         steps.push_back(nextStep);
rt300@41:         
rt300@41:         if (SPACER_BARS){
rt300@41:             nextStep.type = AnimStep::MATCHING_LAST;
rt300@41:             steps.push_back(nextStep);
rt300@41:         }
rt300@41:         n++;
rt300@41:     }
rt300@41:     // move back to neutral
rt300@41:     nextStep.presetIndex = -1;
rt300@41:     nextStep.type = AnimStep::MATCHING_LAST;
rt300@41:     nextStep.whichInSequence = END_NEUTRAL_MATCH;
rt300@41:     nextStep.difficulty = 0;
rt300@41:     nextStep.showsGuides = false; // fact that preset is -1 indicates end of each seq
rt300@41:     nextStep.showsIcons = false;
rt300@41:     nextStep.showsResultsAtEnd = true; // to record neutral hit
rt300@41:     steps.push_back(nextStep);
rt300@41: }
rt300@32: //-------------------------------------------------------------------
rt300@32: void SequenceController::generateASoundOnlyRun(int run, int numInSequence){
rt300@32:     
rt300@32:     // here the preview is sound only
rt300@32:     float curTempo = MIN_TEMPO;
rt300@32:     int seqNo = 0;
rt300@32:     AnimStep nextStep;
rt300@43:     nextStep.totalLengthOfSeq = numInSequence;
rt300@43:     
rt300@32:     for(int tempoLevel = 0; tempoLevel < NUM_TEMPO_STEPS; tempoLevel++){
rt300@32:         // first we have a preparation count in
rt300@32:         nextStep.presetIndex = -1; // minus one means "blank"
rt300@32:         nextStep.runNumber = run;
rt300@32:         nextStep.seqNumber = seqNo;
rt300@32:         nextStep.whichInSequence = 0;
rt300@43:         
rt300@35:         nextStep.difficulty = 0;
rt300@48:         nextStep.timeAllowedMs = timeIntervalsHard[tempoLevel];
rt300@48:         nextStep.setTempoFromTime();
rt300@32:         nextStep.showsGuides = true; // guide shown for neutral point
rt300@32:         nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
rt300@32:         nextStep.showsResultsAtEnd = false;
rt300@32:         steps.push_back(nextStep);
rt300@32:         
rt300@32:         // generate a sequence of random preset indices
rt300@32:         vector<int> stepPresetIndices = randomSequence(numInSequence);
rt300@32:         nextStep.thisSequence = stepPresetIndices;
rt300@32:         
rt300@42:         makePreview(stepPresetIndices, run, nextStep);
rt300@43:         makePreview(stepPresetIndices, run, nextStep);
rt300@32:         
rt300@42:         // make matching sequence without icon seq help
rt300@42:         makeMatchingSequence(stepPresetIndices, run, nextStep);
rt300@42:         makeMatchingSequence(stepPresetIndices, run, nextStep);
rt300@32:         
rt300@32:         
rt300@32:         steps.back().isLastOfSeq = true;
rt300@32:         curTempo += tempoInc;
rt300@32:         seqNo++;
rt300@32:     }
rt300@32:     // shows last result ?
rt300@32:     nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
rt300@32:     steps.push_back(nextStep);
rt300@32: }
rt300@27: //-------------------------------------------------------------------
rt300@27: 
rt300@21: void SequenceController::generateARun(int run, int numInSequence){
rt300@21:     float curTempo = MIN_TEMPO;
rt300@21:     int seqNo = 0;
rt300@27:     AnimStep nextStep;
rt300@21:     for(int tempoLevel = 0; tempoLevel < NUM_TEMPO_STEPS; tempoLevel++){
rt300@21:         
rt300@22:         
rt300@22:         
rt300@22:         // first we have a preparation count in
rt300@22:         nextStep.presetIndex = -1; // minus one means "blank"
rt300@22:         nextStep.runNumber = run;
rt300@22:         nextStep.seqNumber = seqNo;
rt300@27:         nextStep.whichInSequence = 0;
rt300@22:         nextStep.tempo = curTempo;
rt300@36:         nextStep.tempoLevel = tempoLevel;
rt300@36:         nextStep.setTimeFromTempo();
rt300@38:         nextStep.showsGuides = false;
rt300@27:         nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
rt300@31:         nextStep.showsResultsAtEnd = false;
rt300@38:         // two neutrals between the new sequences
rt300@38:         steps.push_back(nextStep);
rt300@38:         nextStep.showsGuides = true;
rt300@27:         steps.push_back(nextStep);
rt300@22:         
rt300@27:         // generate a sequence of random preset indices
rt300@27:         vector<int> stepPresetIndices = randomSequence(numInSequence);
rt300@27:         nextStep.thisSequence = stepPresetIndices;
rt300@43:         
rt300@22:         // make preview sequence
rt300@35:         int n = 1;
rt300@22:         for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@21:             // put loader
rt300@21:             
rt300@21:             nextStep.presetIndex = *si;
rt300@21:             nextStep.runNumber = run;
rt300@21:             nextStep.seqNumber = seqNo;
rt300@27:             nextStep.whichInSequence = n;
rt300@43:             
rt300@27:             nextStep.showsGuides = true;
rt300@31:             nextStep.showsIcons = true;
rt300@31:             nextStep.showsResultsAtEnd = false;
rt300@27:             nextStep.type = AnimStep::PREVIEW_MOVE;
rt300@21:             steps.push_back(nextStep);
rt300@21:             
rt300@29:             if (SPACER_BARS){
rt300@35:                 nextStep.type = AnimStep::PREVIEW_LAST;
rt300@29:                 steps.push_back(nextStep);
rt300@29:             }
rt300@21:             n++;
rt300@21:         }
rt300@27:         
rt300@31:         // move back to neutral
rt300@31:         nextStep.presetIndex = -1;
rt300@31:         nextStep.type = AnimStep::PREVIEW_MOVE;
rt300@35:         nextStep.difficulty = 0;
rt300@35:         nextStep.whichInSequence = 0;
rt300@35:         nextStep.showsResultsAtEnd = true;
rt300@27:         steps.push_back(nextStep);
rt300@22:         
rt300@31:         // make GUIDED sequence
rt300@35:         n = 1;
rt300@31:         for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@31:             // put loader
rt300@35:             nextStep.difficulty = 1;
rt300@31:             nextStep.presetIndex = *si;
rt300@31:             nextStep.seqNumber = seqNo;
rt300@31:             nextStep.whichInSequence = n;
rt300@43:             
rt300@31:             nextStep.showsGuides = true;
rt300@31:             nextStep.showsIcons = true;
rt300@31:             nextStep.showsResultsAtEnd = true;
rt300@35:             nextStep.type = AnimStep::MATCHING_MOVE;
rt300@31:             steps.push_back(nextStep);
rt300@43:             
rt300@31:             if (SPACER_BARS){
rt300@35:                 nextStep.type = AnimStep::MATCHING_LAST;
rt300@31:                 steps.push_back(nextStep);
rt300@31:             }
rt300@31:             n++;
rt300@31:         }
rt300@31:         // move back to neutral
rt300@31:         nextStep.presetIndex = -1;
rt300@39:         nextStep.whichInSequence = 0;
rt300@35:         nextStep.type = AnimStep::MATCHING_LAST;
rt300@31:         nextStep.showsResultsAtEnd = false;
rt300@31:         steps.push_back(nextStep);
rt300@31:         
rt300@38:         
rt300@31:         // make matching sequence with icon seq help
rt300@35:         n = 1;
rt300@22:         for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@21:             // put loader
rt300@35:             nextStep.difficulty = 2;
rt300@21:             nextStep.presetIndex = *si;
rt300@27:             nextStep.whichInSequence = n;
rt300@43:             
rt300@31:             nextStep.showsGuides = false;
rt300@31:             nextStep.showsIcons = true;
rt300@27:             nextStep.type = AnimStep::MATCHING_MOVE;
rt300@31:             nextStep.showsResultsAtEnd = true;
rt300@22:             steps.push_back(nextStep);
rt300@21:             
rt300@29:             if (SPACER_BARS){
rt300@35:                 nextStep.type = AnimStep::MATCHING_LAST;
rt300@29:                 steps.push_back(nextStep);
rt300@43:                 
rt300@29:             }
rt300@21:             n++;
rt300@43:             
rt300@21:         }
rt300@21:         
rt300@31:         // move back to neutral
rt300@31:         nextStep.presetIndex = -1;
rt300@39:         nextStep.whichInSequence = 0;
rt300@35:         nextStep.type = AnimStep::MATCHING_LAST;
rt300@31:         nextStep.showsResultsAtEnd = false;
rt300@31:         steps.push_back(nextStep);
rt300@31:         
rt300@31:         // make matching sequence WITHOUT icon seq help
rt300@35:         n = 1;
rt300@31:         for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
rt300@31:             // put loader
rt300@35:             nextStep.difficulty = 3;
rt300@31:             nextStep.presetIndex = *si;
rt300@31:             nextStep.whichInSequence = n;
rt300@31:             
rt300@31:             nextStep.showsGuides = false;
rt300@35:             nextStep.showsIcons = false;
rt300@31:             
rt300@31:             nextStep.type = AnimStep::MATCHING_MOVE;
rt300@31:             nextStep.showsResultsAtEnd = true;
rt300@35:             
rt300@31:             steps.push_back(nextStep);
rt300@31:             
rt300@31:             if (SPACER_BARS){
rt300@35:                 nextStep.type = AnimStep::MATCHING_LAST;
rt300@31:                 steps.push_back(nextStep);
rt300@31:                 
rt300@31:             }
rt300@31:             n++;
rt300@31:             
rt300@31:         }
rt300@31:         
rt300@35:         nextStep.type = AnimStep::MATCHING_LAST;
rt300@35:         nextStep.presetIndex = -1;
rt300@39:         nextStep.whichInSequence = 0;
rt300@39:         nextStep.showsGuides = false; // so you know when to go to neutral
rt300@31:         nextStep.showsResultsAtEnd = false;
rt300@31:         steps.push_back(nextStep);
rt300@31:         
rt300@21:         steps.back().isLastOfSeq = true;
rt300@21:         curTempo += tempoInc;
rt300@21:         seqNo++;
rt300@21:         cout << endl;
rt300@21:         
rt300@21:     }
rt300@27:     // ANIM nextStep.setAsBlankCounter();
rt300@27:     nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
rt300@22:     steps.push_back(nextStep);
rt300@21:     
rt300@21: }
rt300@27: //-----------------------------------------------------------------------
rt300@31: void SequenceController::saveResultForCurrentStep(TrainingTestResult result){
rt300@31:     (*currentStep).saveResult(result);
rt300@31:     
rt300@31: }
rt300@31: //-----------------------------------------------------------------------
rt300@31: TrainingTestResult SequenceController::getResultForPreviousStep(){
rt300@31:     if (currentStep == steps.begin()){
rt300@43:         
rt300@31:         cout << "ERROR - " << endl;
rt300@43:         
rt300@31:     }
rt300@31:     return (*currentStep--).result;
rt300@31:     
rt300@43:     
rt300@31: }
rt300@31: //-----------------------------------------------------------------------
rt300@21: 
rt300@21: 
rt300@21: int SequenceController::getRandomButNot(int max, vector<int> notThese){
rt300@21:     
rt300@21:     bool there = true;
rt300@21:     int randomInt = rand() % max;
rt300@21:     
rt300@21:     if (notThese.size()){
rt300@21:         while(there){
rt300@21:             randomInt = rand() % max;
rt300@21:             vector<int>::iterator result = std::find(notThese.begin(), notThese.end(), randomInt);
rt300@21:             there =  (result != notThese.end());
rt300@21:         }
rt300@21:     }
rt300@21:     return randomInt;
rt300@21:     
rt300@21: };