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

#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( );

}