crossFour.cpp

#include "crossFour.h"
#include "termmanip.h"
#include "keystream.h"
#include <unistd.h>
#include <iostream>

using namespace std;

//constructors and destructors
CrossFour::CrossFour() : CrossFour(1,1)
{

}

CrossFour::CrossFour(int cx, int cy) : Widget(cx, cy, 35, 1), pegs(9)
{
  //build the pegses
  for(int i=0; i<pegs.size(); i++) {
    pegs[i] = new Peg(x()+i*4, y());
  }

  reset();    
}

CrossFour::~CrossFour() 
{
  for(int i=0; i<pegs.size(); i++) {
      delete pegs[i];
  }    
}

//display our puzzle
void 
CrossFour::display() 
{
  for(int i=0; i<pegs.size(); i++) {
      pegs[i]->display();
  }    
}

//cursor movements
void 
CrossFour::left()
{
  pegs[cx]->deselect();
  cx--;
  if(cx < 0) cx = pegs.size()-1;
  pegs[cx]->select();    
}


void 
CrossFour::right()
{
  pegs[cx]->deselect();
  cx++;
  cx %= pegs.size();    
  pegs[cx]->select();
}


//perform a move
bool 
CrossFour::move()
{
  //selecting source?
  if(sx == -1) {
    //validate our selection
    if(!pegs[cx]->isOccupied()) return false;

    //source is selected!
    sx = cx;
    return true;
  }

  //select destination and complete the move
  
  //validate direction
  if(pegs[sx]->color() == blue and sx >= cx){
      sx = -1;
      return false;
  } 
  if(pegs[sx]->color() == red and sx <= cx) {
    sx = -1;
    return false;
  }

  int d = sx - cx;
  if(d<0) d*=-1;

  //validate the distance
  if(d < 1 or d > 2) {
      sx = -1;
      return false;
  }

  if(pegs[cx]->isOccupied()) {
      sx = -1;
      return false;
  }

   //it's valid!  Move it!
   pegs[cx]->color(pegs[sx]->color());
   pegs[sx]->take();
   pegs[cx]->place();
   sx =-1;
   display();
  return true;    
}

//autosolver
void
CrossFour::solve() 
{
    Solver *solution = new Solver(this);
    cout << cursorPosition(1,2) << "Thinking...";
    cout.flush();
    backtrack(solution);   
    cout << cursorPosition(1,2) << clearLine;
    cout.flush();

/*    Solver *move = solution;
    while(move) {
        displayState(move->state);
        move = (Solver*) move->after();
    }
*/
    delete solution;
}


//reset the puzzle to starting position
void 
CrossFour::reset()
{
  //blue pegs
  for(int i=0; i<pegs.size()/2; i++) {
      pegs[i]->place();
      pegs[i]->color(blue);
  }

  //blank peg
  pegs[pegs.size()/2]->take();    

  //red pegs
  for(int i=pegs.size()/2+1; i<pegs.size(); i++) {
    pegs[i]->place();
    pegs[i]->color(red);
  }

  //select the default peg
  sx=-1;
  cx = pegs.size()/2;
  pegs[cx]->select();
  display();
}


CrossFour::Solver::Solver(CrossFour *puzzle)
{
    //we have made no move!
    movedPeg=-1;
    nextTrial = 0;
    state[0]='B';
    state[1]='B';
    state[2]='B';
    state[3]='B';
    state[4]=' ';
    state[5]='R';
    state[6]='R';
    state[7]='R';
    state[8]='R';
    _before = _after = NULL;
    this->puzzle = puzzle;
}

 
CrossFour::Solver::Solver(CrossFour *puzzle, char state[], int movedPeg)
{
    this->puzzle = puzzle;
    this->movedPeg = movedPeg;
    nextTrial=0;
    //copy the pegs
    for(int i=0; i<9; i++) {
        this->state[i] = state[i];
    } 
    _before = _after = NULL;
}


bool 
CrossFour::Solver::reject()
{
    if(accept()) return false;

    //iterate 
    for(int i = 0; i < 9; i++) {
        if(state[i] == 'B' && i != 6) {
            if(state[i+2] == ' ') {
                return false;
            }
       }
        if(state[i] == 'B' && i != 7) {
            if(state[i+1] == ' ') {
                return false;
            }
       }
        if(state[i] =='R' && i != 0) {
            if(state[i-1] == ' ') {
                return false;
            }
       }
        if(state[i] =='R' && i > 1) {
            if(state[i-2] == ' ') {
                return false;
            }
       }
    }
    return true;
}



bool 
CrossFour::Solver::accept()
{
    puzzle->displayState(state);
    //iterate through the state
    for(int i = 0; i <9; i++) {
        if(i >= 0 and i <= 3) {
            if (state[i] != 'R') return false;
        }
        if(i == 4) {
            if (state[i] != ' ') return false;
        }
        if(i >= 5 and i <= 8) {
            if (state[i] != 'B') return false;
        }
    }
    //if we made it this far, everything is correct vibes

    return true;
}
 

MoveState* 
CrossFour::Solver::next()
{
    Solver *moved = NULL;

    for(nextTrial; !moved and nextTrial <= 8; nextTrial++)
    {
        switch(state[nextTrial]){
            case 'B':
                if(nextTrial < 8 and state[nextTrial+1] == ' ')
                {
                    moved = new Solver(puzzle, state, movedPeg);
                    _after = moved;
                    moved->_before = this;
                    moved->state[nextTrial] = ' ';
                    moved->state[nextTrial+1] = 'B';
                } else if(nextTrial < 7 and state[nextTrial+2] == ' ') {
                    moved = new Solver(puzzle, state, movedPeg);
                    _after = moved;
                    moved->_before = this;
                    moved->state[nextTrial] = ' ';
                    moved->state[nextTrial+2] = 'B';
                }
                break;
            case 'R':
                if(nextTrial > 0 and state[nextTrial-1] == ' ')
                {
                    moved = new Solver(puzzle, state, movedPeg);
                    _after = moved;
                    moved->_before = this;
                    moved->state[nextTrial] = ' ';
                    moved->state[nextTrial-1] = 'R';
                } else  if(nextTrial > 1 and state[nextTrial-2] == ' ') {
                    moved = new Solver(puzzle, state, movedPeg);
                    _after = moved;
                    moved->_before = this;
                    moved->state[nextTrial] = ' ';
                    moved->state[nextTrial-2] = 'R';
                }
                break;

            default:
                break;
        }
     
    }

    return moved;
}

//move "memory"
MoveState* 
CrossFour::Solver::before()
{
    return _before;    
}


MoveState* 
CrossFour::Solver::after()
{
    return _after;    
}

//display the current state
void CrossFour::displayState(char state[]) 
{
    for(int i=0; i<9; i++) {
       pegs[i]->take();
       switch(state[i]) {
           case 'B':
            pegs[i]->color(blue);
            pegs[i]->place();
            break;
           case 'R':
            pegs[i]->color(red);
            pegs[i]->place();
            break;
       }
    }
    display();
    cout.flush();
    usleep(250000);
}