Segmentation Fault (Continued)

#include "SDL_MainWindow.hpp"
#include "MasterMind.hpp"


void initialize_tacs(std::vector<Tac>&, Board&);
void display_tacs(std::vector<Tac>::iterator, std::vector<Tac>::iterator, SDL_Surface*);
void handle_tac_events(std::vector<Tac>::iterator, std::vector<Tac>::iterator, int&, int&, Board&);

int main(int args, char** argv)
{
    SDL_Window window(SCREEN_WIDTH, SCREEN_HEIGHT, BPP, 
                    SDL_HWSURFACE | SDL_DOUBLEBUF, "MasterMind");
    Board board;
  
    std::vector<Tac> vTacs;
    initialize_tacs(vTacs, board);

    bool quit = false;
    int mouse_x, mouse_y;

    while (quit == false)
    {
      SDL_Event event;
      while (SDL_PollEvent(&event)) 
      {  
        if (event.type == SDL_QUIT)
          quit = true;
	if (event.type == SDL_MOUSEBUTTONDOWN)
	{
	  SDL_GetMouseState(&mouse_x, &mouse_y);
	  //handle_tac_events(vTacs.begin(), vTacs.end(), mouse_x, mouse_y, board);
        }
      }
      display_tacs(vTacs.begin(),vTacs.end(), board.me());
      board.drawOn(window.me());      
      SDL_Flip(window.me());
    }
    return 0;
}


void initialize_tacs(std::vector<Tac>& vTacs, Board& board)
{
  for (int i = 0; i < 8 ; i++)
  {
    vTacs.push_back(Tac((Color)i, board));
  }
  return;
}

void display_tacs(std::vector<Tac>::iterator iter, std::vector<Tac>::iterator end, SDL_Surface* board)
{
  for (; iter != end;  ++iter)
  {
    iter->drawOn(board);
  } 
  return;
}

void handle_tac_events(std::vector<Tac>::iterator iter, std::vector<Tac>::iterator end, int& x, int& y, Board& board)
{
  for (; iter != end ; ++iter)
  {
    iter->handleEvents(x, y, board);
  } 
  return;

}

#include <fstream>
#include <vector>
#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "MasterMind.hpp"



SDL_Surface* loadImage(const std::string& filename)
{  
   SDL_Surface* loadedImage = NULL;   
   SDL_Surface* optimizedImage = NULL;   
   loadedImage = IMG_Load(filename.c_str());  
   if (loadedImage != NULL) 
   {
     optimizedImage = SDL_DisplayFormat(loadedImage); //to ensure format is same for image and surface to be blitted. 
     SDL_FreeSurface(loadedImage);  
   } 
   else
     cerr << "Unable to initialize image," << filename << endl;
   return optimizedImage; 
}

//SDL_FreeSurface(SDL_Surface*) //this is a biggy man...

/* 
** Begin Hole
*/

Hole::Hole()
{
}
bool Hole::isOnHole(Point const &point) const
{
  if (point.x <= (center.x + RADIUS) && point.x >= (center.x - RADIUS)
  &&  point.y <= (center.y + RADIUS) && point.y >= (center.x - RADIUS))
    return true;
  return false;
}
/* 
** End Hole
*/

/*
**Begin Tac
*/
Tac::Tac(Color colour, Board& game_board): color(colour), is_clicked(false)
{
  switch (color)
  {
    case BLACK: tac = loadImage(black);
                break;
    case WHITE: tac = loadImage(white);
                break;
    case RED:   tac = loadImage(red);
                break;
    case BLUE:  tac = loadImage(blue);
                break;
    case YELLOW:tac = loadImage(yellow);
                break;
    case PURPLE:tac = loadImage(purple);
                break;
    case GREEN: tac = loadImage(green);
                break;
    case BROWN: tac = loadImage(brown);
                break;
    default: cerr << "unable to load image, invalid color specified." << endl;
  }   
  for (std::vector<Hole>::iterator i(game_board.tacDefaults.begin()); i != 
	 game_board.tacDefaults.end() ; ++i)
  {
    if (i->getID() == colour+1)  //set location to default location for color.
      location = i->getCenter();
  }
}


void Tac::drawOn(SDL_Surface* dest)
{
  SDL_Rect cord;
  cord.x = location.x;
  cord.y = location.y;
  SDL_BlitSurface(tac, NULL, dest, &cord);
}

bool Tac::isOnTac(Point const &point) const
{
  if (point.x <= (location.x + RADIUS*2) && point.x >= (location.x)
      &&  point.y <= (location.y + RADIUS*2) && point.y >= (location.y))
    return true;
  return false;
}

void Tac::handleEvents(int& x, int& y, Board& board)
{
  Point mouseLocation(x,y);
  if (is_clicked)
  {
    std::vector<Hole>::iterator iHoles(board.guess_holes.begin());
    for (; iHoles != board.guess_holes.end(); ++iHoles)
    {  
      if (iHoles->isOnHole(mouseLocation))
      {
        location = iHoles->getCenter();
	location.x -= RADIUS;
	location.y -= RADIUS; //to center out where the tac is drawn
      }
    }
    is_clicked = false;
  }
  else
    is_clicked = isOnTac(mouseLocation);
}
  
Tac::~Tac()
{
  SDL_FreeSurface(tac);
}
/*
** End Tac
*/
/*
** Begin Board
*/
Board::Board(): columns(5), rows(12)
{
  board = loadImage(boardFile);
  std::ifstream guess_holeS (cordFile.c_str());
  std::ifstream tac_defaults (tacFile.c_str());
  int num,x,y;
  guess_holes.reserve(rows*columns+5); //5 is the answer holes.
  tacDefaults.reserve(8); //8 is the # of colors.
  while (guess_holeS >> num)
  {
    guess_holeS >> x;
    guess_holeS >> y; 
    Point cordinate(x,y);
    Hole hole(cordinate, num);   //set cordinate and ID on hole
    guess_holes.push_back(hole); //then add the hole to the vec.    
  } 
  while (tac_defaults >> num)
  {
    tac_defaults >> x; 
    tac_defaults >> y;  
    Point cordinate(x,y);
    Hole hole(cordinate, num);
    tacDefaults.push_back(hole);
  }
}  

Board::~Board()
{
  SDL_FreeSurface(board);
  
}

void Board::drawOn(SDL_Surface* dest)
{
  SDL_Rect location;
  location.x = 0;
  location.y = 0;
  SDL_BlitSurface(board, NULL, dest, &location);
}

/*
** End Board
*/