//hex_board.cc 
#include "hex_board.h"



hex_board::hex_board():SIZE(15)
{
  int i;
  board = new testSquare* [15];

  for (i = 0; i < 15; i++)
    board[i] = new testSquare[15];

  makeBlankBoard();

}

hex_board::hex_board(int largeness){
  if (largeness < 1) largeness = 15;

  int i;
  board = new testSquare* [largeness];

  for (i = 0; i < 15; i++)
    board[i] = new testSquare[largeness];

  SIZE = largeness;
  makeBlankBoard();
}

void hex_board::makeBlankBoard(){
  int i, j;
  
  for (i=0; i<SIZE; i++)
      for (j=0; j<SIZE; j++)
	{            
	  board[i][j] = testSquare();
	  board[i][j].contains = EMPTY;
	}
}


void hex_board::setCoord(int a, int b, occupantType c)
{
  board[a][b].put(c);
}

void hex_board::doIt(Move &here, occupantType c)
{
  board[here.hex.x][here.hex.y].put(c);
  
}


bool hex_board::directionConnected(int i, int j, occupantType side)
{
  bool result = false;
  
  board[i][j].markTested();
  
  //Avoids loops since a loop would test some square twice (infinitely).
  //Despite a looped square not having been tested, it is necessarily
  //being tested by the current calculation.
  
  int k,l;
  
  //Does it matter which way we pick to go first?  Straight seems logical.
  
  
  for(k=i-1; k<i+2; k++){
    for(l=j-1;l<j+2;l++){
      
      if((i+l)==(j+k)) continue;
      //The `\ diagonal' is not connected.
      
      
      if ((k<0 && side == VERT) || (l < 0  && side == HORZ))
	{
	  result = true;
	  break; 
	}
      //When the square tested is at the edge, then the answer is yes.
      
      if(k<0 || l<0 || k>=SIZE || l>=SIZE) continue;
      //Make sure the indices are in the valid range.		
      
      
      if (board[k][l].contains == side && board[k][l].wasTested() == false) 
	{
	  if (directionConnected(k, l, side))
	    {
	      result = true;  
	      break;
	    }
	}
    }
  }
  
  return result;
}


bool hex_board::isWon(occupantType side)
{
  int otherEdge, j;
  bool result = false;
  
  otherEdge = SIZE - 1;
  for(j=0; j < SIZE; j++)
    {
      if (side == VERT){
	if(board[otherEdge][j].contains == VERT && board[otherEdge][j].wasTested() == false)
	  {
	    
	    //We have to test whether the bottom is connected to the top.
	    
	    
	    if(directionConnected(otherEdge, j, side))
	      {
		result = true;
		break;
	      }
	  }
      }
      else {
	if(board[j][otherEdge].contains == HORZ && board[j][otherEdge].wasTested() == false)
	  {
	    
	    //We have to test whether the bottom is connected to the top.
	    
	    
	    if(directionConnected(j, otherEdge, side))
	      {
		result = true;
		break;
	      }
	  }
	
	
      }
      
      
      
    }
  
  return result;
}



void hex_board::displayhex_board()
{
  int i, j;
  int k;
  
  
  
  for(i=0;i<SIZE;i++){
    
    
    for(k=0; k<i;k++){
      cout << " ";
    }
    
    cout << (SIZE - i) << " |";
    for(j=0;j<SIZE;j++){
       board[i][j].contains.display();
    }
    cout << "|" << "\n";
  }
  for(k=0; k< SIZE;k++){
    cout << " ";
  }
  cout << "   ";

  for(k=1; k<= SIZE;k++){
    cout << k <<"  ";
  }

  cout << "/n";
 
	
}


void hex_board::initialize_board()
{
  int i,j;
  int temp;
  
  for(i=0;i<SIZE;i++){
    for(j=0;j<SIZE;j++){
      cout << "What is there at" << i << ", " << j << "?";
      
      
      cin >> temp;
      
      
      
      cout << temp << "at" << i << ", " << j << "?";
      
      
      if(temp==1) board[i][j].contains = VERT;
      if(temp==2) board[i][j].contains = HORZ;
    }
  }
  
}



int hex_board::numberOfEmpties()
{
  int i,j;
  int total=0;
  
  
  for(i=0; i<SIZE;i++){
    for(j=0;j<SIZE;j++){
      if (board[i][j].contains == EMPTY)
	{
	  total++;
	}
    }
  }
  
  
  return total;
}