comparison TrainingScoreManager.h @ 32:75202498bee9

perform mode (no guides at all)

 #include <iostream>
 #include "ofMain.h"
 //#include "SequenceController.h"
 #include "algorithms.h"
 #include "globalVariables.h"
+#include "eventLogger.h"
+
+extern EventLogger eventLogger;
 //-------------------------------------------------------------
 
 struct TrainingTestResult{
     float realDistanceToTarget;
     int targetBandHit; // eg bullseye = 0 edge = 7

 class TrainingScoreManager{
     
     // equiv of score bit of testController
 public:
     
-    TrainingTestResult getScoreForAnswer(vector<int> targetParams, vector<int> startPosition, vector<int> answer, int timeAllowed) const {
+    
+    TrainingTestResult getScoreForAnswer(vector<int> targetParams, vector<int> startPosition, vector<int> answer, int timeAllowed) {
         TrainingTestResult result;
         stringstream msg;
         int score = 0;
         // work out euc distance from actual point
         //for_each(answer.begin(),answer.end(),printThing<int>());
         //for_each(targetParams.begin(),targetParams.end(),printThing<int>());
         float initDist = euclideanDistance(startPosition, answer);
         float dist = euclideanDistance(targetParams, answer);
         
         float TP = calculateThroughput(TOTAL_NUM_PARAMS, dist, initDist, timeAllowed/1000.);
-        
-        cout << TP << endl;
         
         auto dimComp = sqrt(TOTAL_NUM_PARAMS);
         int band = -1;
         if (dist < TARGET_SCORE_CC_BAND*dimComp){
             score = 50;

             msg << "MISSED COMPLETELY!" << endl;
             
             
         }
         msg << "Distance from target: " << dist << endl;
-        msg << "Basic Score: " << round(TP*10) << endl;
+        msg << "Score: " << round(TP*10) << endl;
         msg << "-----" << endl;
         msg << "Time allowed: " << timeAllowed/1000.0 << endl;
 
         msg << "-----" << endl;
 

         }else{
             c = ofColor(150,235,200,255);
         }
         result.colorBand = c;
 
+        totalScored += score;
+        
+        vector<int> details;
+        details.push_back(result.realDistanceToTarget);
+        details.push_back(result.targetBandHit);
+        details.push_back(result.timeAllowed);
+        details.push_back(result.score); // 10 x throughput
+        
+        eventLogger.logEvent(TRAINING_RESULT, details);
+        
         
         return result;
     }
+    
+    int getScore(){return totalScored;};
+    
 private:
+    
+    
     float calculateThroughput(int numDims, float endDistance, float startDistance, float time) const{
         
         float ISSR = numDims * log2( startDistance / endDistance);
+        cout << "==========Result======= " << endl;
         cout << "start: " << startDistance << endl;
         cout << "end:   " << endDistance << endl;
         cout << "ISSR:  " << ISSR << endl;
+        cout << "time:  " << time << endl;
         float TP = ISSR / time;
+        cout << "TP:  " << TP << endl;
         return TP;
     }
     float euclideanDistance(vector<int> v1, vector<int> v2) const{
         if (v1.size() != v2.size()){
             cout << "ERROR ERROR: vectors must be same length for Mr Euclid";

         float ans = std::accumulate(v1.begin(),v1.end(),0.0);
         
         return sqrt(ans);
         
     };
+    int totalScored;
     
 };
 #endif /* defined(__riftathon__TrainingScoreManager__) */