/*
Energie-Quiz-Roboter EQR-2002
2 Spieler-Modus

(C) CLIP & KLAR, 200020305
slot 1

läuft nur auf einem RXC 2.0!
*/

// sensors
#define WS SENSOR_1
#define BL SENSOR_3
// motors
#define PKTWS OUT_A
#define ERGEBNIS OUT_B
#define PKTBL OUT_C
//variablen
int speed=7;
int frag[20];
int m, x, y, z, weiter;
int abg=0, erg=0, erg_bl=0, erg_ws=0;

task main() {
  // configure the sensors
  SetSensor(BL, SENSOR_TOUCH);
  SetSensor(WS, SENSOR_TOUCH);
  
  //Reset Anzeigen
  pkt_ws(-11);
  antwort(-22);
  pkt_bl(-11);
  
  //Richtige Antworten
  frag[0] = 1; frag[10] = 2;
  frag[1] = 2; frag[11] = 3;
  frag[2] = 3; frag[12] = 1;
  frag[3] = 1; frag[13] = 2;
  frag[4] = 2; frag[14] = 3;
  frag[5] = 3; frag[15] = 1;
  frag[6] = 1; frag[16] = 2;
  frag[7] = 2; frag[17] = 3;
  frag[8] = 3; frag[18] = 1;
  frag[9] = 1; frag[19] = 2;

  //GO!
  //start beginn;
  while(true) {
    x=Random(19);                      // roll the dice!
    m=Random(2);                       // Multiplikator
    z=x+1+10*m;                        // erzeuge 60 Fragen aus 20er Array
    SetUserDisplay(z, 0);              // display Frage
    y=frag[x];
    start tast_bl;                     // warte auf BL Antwort
    start tast_ws;                     // warte auf WS Antwort
    weiter=0;
    while(weiter==0);
    if (erg_bl==10) {                   // BL gewinnt
      ergebnis(5);
      SetUserDisplay(0, 0);
      StopAllTasks();
    }
    if (erg_ws==10) {                   // WS gewinnt
      ergebnis(4);
      SetUserDisplay(0, 0);
      StopAllTasks();
    }
  }
}

task tast_bl() {
  while(true) {
    //gedrückt?
    if(BL == 1) {                      // gedrückt!
      stop tast_ws;
      start react; abg=0; erg=1;       // starte Timer
      while(BL==1);                    // warten auf Loslassen
      while (abg==0) {                 // Zeit abgelaufen?
        if(BL == 1) {
          while(BL==1);                // wiederholtes Drücken
          erg++;
        }
      }
      if (erg==y) {                        // richtige Antwort
         pkt_bl(1);
         erg_bl++;
      }
      else {                               // falsche Antwort
           pkt_bl(-1);
           if (erg_bl>0) erg_bl--;
           ergebnis(y);
      }
      weiter=1;                           // Tasteneingabe fertig
      stop tast_bl;
    }
  }
}

task tast_ws() {
  while(true) {
    //gedrückt?
    if(WS == 1) {                      // gedrückt!
      stop tast_bl;
      start react; abg=0; erg=1;       // starte Timer
      while(WS==1);                    // warten auf Loslassen
      while (abg==0) {                 // Zeit abgelaufen?
        if(WS == 1) {
          while(WS==1);                // wiederholtes Drücken
          erg++;
        }
      }
      if (erg==y) {                        // richtige Antwort
         pkt_ws(1);
         erg_ws++;
      }
      else {                               // falsche Antwort
           pkt_ws(-1);
           if (erg_ws>0) erg_ws--;
           ergebnis(y);
      }
      weiter=1;                           // Tasteneingabe fertig
      stop tast_ws;
    }
  }
}

task react() {                            // Wartezeit auf Tastenende
  ClearTimer(0);
  while (true) {
    if (Timer(0) > 20) {
      abg=1;
      stop react;
    }
  }
}

void ergebnis(int steps) {             // umwandlung Antwort --> Ergebnisanzeige
  //Display Ergebnis
  //y=frag[x];
  switch(steps) {
    case 1:                            // Antwort 1
      antwort(12);
      break;
    case 2:                            // Antwort 2
      antwort(10);
      break;
    case 3:                            // Antwort 3
      antwort(5);
      break;
    case 4:                            // WS gewinnt
      antwort(19);
      break;
    case 5:                            // BL gewinnt
      antwort(21);
      break;
  }
  Wait(200);
  //Display zurücksetzen
  switch(steps) {
    case 1:
      antwort(-13);
      break;
    case 2:
      antwort(-11);
      break;
    case 3:
      antwort(-6);
      break;
  }
}

void antwort(int steps) {              // hoch / runterzählen Ergebnis
  int ergx=0;
  Off(ERGEBNIS);
  SetPower(ERGEBNIS,speed);
  if (steps > 0)
    {
    Fwd(ERGEBNIS);
    }
  else
    {
    Rev(ERGEBNIS);
    }
  while(ergx<abs(steps)) {
    OnFor(ERGEBNIS,18);
    Float(ERGEBNIS);
    Wait(20);
    ergx++;
  }
}

void pkt_bl(int steps) {               // hoch / runterzählen blaue Punkte
  int ergx=0;
  Off(PKTBL);
  SetPower(PKTBL,speed);
  if (steps > 0)
    {
    Fwd(PKTBL);
    }
  else
    {
    Rev(PKTBL);
    }
  while(ergx<abs(steps)) {
    OnFor(PKTBL,18);
    Float(PKTBL);
    Wait(20);
    ergx=ergx+1;
  }
}

void pkt_ws(int steps) {               // hoch / runterzählen weisse Punkte
  int ergx=0;
  Off(PKTWS);
  SetPower(PKTWS,speed);
  if (steps > 0)
    {
    Rev(PKTWS);
    }
  else
    {
    Fwd(PKTWS);
    }
  while(ergx<abs(steps)) {
    OnFor(PKTWS,18);
    Float(PKTWS);
    Wait(20);
    ergx=ergx+1;
  }
}