source: liacs/alg/bantumi/branches/spel1.cc@ 6

#include <iostream>

using namespace std;

float Zetten = 0;
// het aantal vakjes dat een veld moet beslaan, hier zit de bank
//***niet*** bij inbegrepen

//Bord 1
const int speelVakjes = 3;
int spelerLaag[speelVakjes + 1] = {3, 3, 3, 0 };
int spelerHoog[speelVakjes + 1] = {3, 3, 3, 0 };

//Bord2
//const int speelVakjes = 4;
//int spelerLaag[speelVakjes + 1] = {3, 2, 2, 2, 0 };
//int spelerHoog[speelVakjes + 1] = {3, 2, 2, 2, 0 };

//Bord3
//const int speelVakjes = 4;
//int spelerLaag[speelVakjes + 1] = {2, 2, 2, 2, 0 };
//int spelerHoog[speelVakjes + 1] = {2, 2, 2, 2, 0 };

const int totaalAantalVakjes = (speelVakjes + 1) * 2;

// een vakje bevat de gegevens van zijn buren, en van de overkant.
// en de inhoud natuurlijk
class vakje {
  public:
    vakje * volgende;
    vakje * vorige;
    vakje * overkant;
    int inhoud;
};

//vakjesarray globaal gedifineerd om zo recursie mogelijk te maken
//voorbeeld, bij speelVakjes = 4;
//0,1,2,3 zijn de normale vakjes, 4 is de bank
//Speler 1 = arraySpeler[0]
//Speler 2 = arraySpeler[1]
vakje * arraySpeler[2][speelVakjes + 1];

//score
int winstMax = 0;
int winstMin = 10000;
int gelijkMax = 0;
int gelijkMin = 10000;

//het creeren van het speelveld.
//de bank staat op positie speelVakjes
void createfield() {
  vakje * huidigeLaag = new vakje;
  vakje * huidigeHoog = new vakje;

//vakjes maken
  for( int vakNummer = 0; vakNummer < speelVakjes; vakNummer++ ) {
    arraySpeler[0][vakNummer] = huidigeLaag;
    huidigeLaag->inhoud = spelerLaag[vakNummer];
    huidigeLaag->volgende = new vakje;
    huidigeLaag->volgende->vorige = huidigeLaag;
    huidigeLaag = huidigeLaag->volgende;
    
    arraySpeler[1][vakNummer] = huidigeHoog;
    huidigeHoog->inhoud = spelerHoog[vakNummer];
    huidigeHoog->volgende = new vakje;
    huidigeHoog->volgende->vorige = huidigeHoog;
    huidigeHoog = huidigeHoog->volgende;
  };

//overkant pointer aanmaken
  for( int vakNummer = 0; vakNummer < speelVakjes; vakNummer++ ) {
    arraySpeler[0][vakNummer]->overkant = arraySpeler[1][speelVakjes-1-vakNummer];
    arraySpeler[1][speelVakjes-1-vakNummer]->overkant = arraySpeler[0][vakNummer];
  };
  
//banken aanmaken
    arraySpeler[0][speelVakjes] = huidigeLaag;
    arraySpeler[0][speelVakjes]->inhoud = spelerLaag[speelVakjes];
    arraySpeler[0][speelVakjes]->volgende = arraySpeler[1][0];
    arraySpeler[0][speelVakjes]->overkant = NULL;
    arraySpeler[1][0]->vorige = arraySpeler[0][speelVakjes];
    
    arraySpeler[1][speelVakjes] = huidigeHoog;
    arraySpeler[1][speelVakjes]->inhoud = spelerHoog[speelVakjes];
    arraySpeler[1][speelVakjes]->volgende = arraySpeler[0][0];
    arraySpeler[1][speelVakjes]->overkant = NULL;
    arraySpeler[0][0]->vorige = arraySpeler[1][speelVakjes];
}


//-met een pointer het spelletje verwerken.
//-dmv van een modulo trucje ernaar kijken of een zet in de eigen vakjes
//eindigd
//geef terug of de speler nog een keertje mag.
vakje * doeZet( bool & tmpSpeler, const int begin, const int aantal,
                int & overkant ) {
  int tmpInt = (begin + aantal) % (totaalAantalVakjes);
  vakje * tmpPointer = arraySpeler[tmpSpeler][begin];
  
  //doen van de echte zetten
  tmpPointer->inhoud = 0;
  for( int i = 0; i < aantal; i++ ) {
    tmpPointer = tmpPointer->volgende;
    tmpPointer->inhoud++;
  };
  
  //controleren bank, dan mag de speler nog een keer
  if( tmpPointer == arraySpeler[tmpSpeler][speelVakjes] ) {
  }
  else {
    //controleren of inhoud 1 is (bestemmingsvakje was dan 0)
    if( tmpPointer->inhoud == 1 ) {
      //controleren of vakje in het eigen domein ligt, zo ja stelen ;-)
      if((0 <= tmpInt) and (tmpInt < speelVakjes)) {
        overkant = tmpPointer->overkant->inhoud;
        tmpPointer->overkant->inhoud = 0;
        tmpPointer->inhoud = 0;
        arraySpeler[tmpSpeler][speelVakjes]->inhoud += (overkant + 1);
      }
    }
    tmpSpeler = not(tmpSpeler);
  }
  return(tmpPointer);
}



//het terugzetten van een zet
//tmpPointer is de pointer naar eind die langzaam terugloopt
void zetTerug(const bool speler, vakje * tmpPointer, const int aantal,
const int overkantAantal ) {
//  //controleren of we met een overkant zet te maken hadden
  if( tmpPointer->inhoud == 0 ) {
    tmpPointer->inhoud++;
    tmpPointer->overkant->inhoud = overkantAantal;
    arraySpeler[speler][speelVakjes]->inhoud -= (overkantAantal + 1);
  }
  //netjes de steentjes in tegengestelde richting terug leggen
  for( int i = 0; i < aantal; i++ ) {
    tmpPointer->inhoud--;
    tmpPointer = tmpPointer->vorige;
  }
  //orspronkelijke aantal weer op het begin vakje leggen
  tmpPointer->inhoud = aantal;
}


// print het eind resultaat
void resultaat( ) {
cout << "-------------------------------" << endl;
cout << "Min Winst : " << winstMin <<endl;
cout << "Min Gelijk: " << gelijkMin <<endl;
cout << "Max Winst : " << winstMax <<endl;
cout << "Max Gelijk: " << gelijkMax <<endl;
cout << "-------------------------------" << endl;
cout << endl;
}


//kijken of wat de eindsituatie opleverd
void checkScore( const int zetten ) {
  Zetten++;
  int scoreSpelerEEN = arraySpeler[0][speelVakjes]->inhoud;
  int scoreSpelerTWEE = arraySpeler[1][speelVakjes]->inhoud;
  for( int i = 0; i < speelVakjes; i++ ) {
    scoreSpelerEEN += arraySpeler[0][i]->inhoud;
    scoreSpelerTWEE += arraySpeler[1][i]->inhoud;
  }
  if( scoreSpelerEEN == scoreSpelerTWEE ) {
    if( zetten < gelijkMin ) {
      gelijkMin = zetten;
    }
    if( zetten > gelijkMax ) {
      gelijkMax = zetten;
    }
  }
  else {
   if( zetten < winstMin ) {
    winstMin = zetten;
    }
    if( zetten > winstMax ) {
      winstMax = zetten;
    }
  }
}


//controleer of het spel afgelopen is voor een speler
bool checkEnd_speler( const bool speler ) {
  for( int i = 0; i < speelVakjes; i++ ) {
    if( arraySpeler[speler][i]->inhoud != 0 ) {
      return(false);
    }
  }
  return(true);
}


//controleer of het spel afgelopen is. Controleer dit eerst voor speler
//0, als deze nog niet afgelopen is controleer dan speler 1
bool checkEnd( ) {
  if( checkEnd_speler(0) ) {
    return(true);
  }
  else {
    return(checkEnd_speler(1));
  }
}


//Lets play a game
//eerst wijst de tmpPointer het begin vakje aan, dan wordt ie
//getransformeerd naar het eind vakje (beginvakje voor terugzetten)
void runGame(const bool spelerAanZet, int zetNummer ) {
  //controleer of het afgelopen is
  if( checkEnd( ) ) {
    checkScore( zetNummer );
    return;
  }
  else {
    int aantal;
    int overkantAantal = 0;
    vakje * tmpPointer;
    bool volgendeSpeler;
    zetNummer++;
    for( int huidigeVakje = 0; huidigeVakje < speelVakjes; huidigeVakje++ ) {
      if( arraySpeler[spelerAanZet][huidigeVakje]->inhoud != 0 ) {
        volgendeSpeler = spelerAanZet;  
        aantal = arraySpeler[spelerAanZet][huidigeVakje]->inhoud;
        tmpPointer = doeZet(volgendeSpeler, huidigeVakje, aantal, overkantAantal );
          runGame( volgendeSpeler, zetNummer );
        zetTerug( spelerAanZet, tmpPointer, aantal, overkantAantal );
      }
    }
  }
}



int main ( ) {
  createfield( );
  runGame( 0, 0 );
  resultaat( );
}