QtConnectThreeWidget is a Qt widget class for a responsive connect-three game. QtConnectThreeWidget is used in, among others, the game ConnectThree.

qtconnectthreewidget.h


#ifndef QTCONNECTTHREEWIDGET_H

#define QTCONNECTTHREEWIDGET_H

//---------------------------------------------------------------------------

#include <bitset>

//---------------------------------------------------------------------------

#include <boost/signals2.hpp>

//---------------------------------------------------------------------------

#include <QWidget>

//---------------------------------------------------------------------------

#include "connectthreewidget.h" //thanks to MOC :-(

#include "connectthree.h"       //thanks to MOC :-(

//struct ConnectThreeWidget;

//---------------------------------------------------------------------------

class QtConnectThreeWidget : public QWidget

{

    Q_OBJECT

public:

  explicit QtConnectThreeWidget(

    QWidget *parent = 0,

    const std::bitset<3>& is_player_human = std::bitset<3>(true),

    const int n_cols = 16,

    const int n_rows = 12);



  void DoComputerTurn();

  int GetActivePlayer() const;

  static const std::string GetVersion();

  static const std::vector<std::string> GetVersionHistory();

  int GetWinner() const;

  bool IsComputerTurn() const;



  ///m_signal_valid_move is emitted on a valid move,

  ///causing the game to be terminated or let

  ///the next player do his/her move.

  boost::signals2::signal<void ()> m_signal_valid_move;



signals:



public slots:



protected:

  void mousePressEvent(QMouseEvent * e);

  void paintEvent(QPaintEvent *);





  private:



  boost::scoped_ptr<ConnectThreeWidget> m_widget;

  const QImage m_player1;

  const QImage m_player2;

  const QImage m_player3;

  const QImage m_empty;

  const QImage& GetImage(const int sprite) const;



  static const int m_sprite_width;

  static const int m_sprite_height;



};

//---------------------------------------------------------------------------

#endif // QTCONNECTTHREEWIDGET_H

qtconnectthreewidget.cpp


//---------------------------------------------------------------------------

#include <QMouseEvent>

#include <QPainter>

//---------------------------------------------------------------------------

#include "connectthree.h"

#include "connectthreewidget.h"

#include "qtconnectthreeresources.h"

#include "qtconnectthreewidget.h"

//---------------------------------------------------------------------------

const int QtConnectThreeWidget::m_sprite_width  = 50;

const int QtConnectThreeWidget::m_sprite_height = 50;

//---------------------------------------------------------------------------

QtConnectThreeWidget::QtConnectThreeWidget(

  QWidget *parent,

  const std::bitset<3>& is_player_human,

  const int n_cols,

  const int n_rows)

  : QWidget(parent),

    m_widget(new ConnectThreeWidget(is_player_human,n_cols,n_rows)),

    m_player1(QtConnectThreeResources::GetInstance()->GetPlayersFilenames()[0].c_str()),

    m_player2(QtConnectThreeResources::GetInstance()->GetPlayersFilenames()[1].c_str()),

    m_player3(QtConnectThreeResources::GetInstance()->GetPlayersFilenames()[2].c_str()),

    m_empty(QtConnectThreeResources::GetInstance()->GetEmptyFilename().c_str())

{

  this->setMinimumWidth( n_cols * m_sprite_width );

  this->setMinimumHeight(n_rows * m_sprite_height);

  this->setMaximumWidth( n_cols * m_sprite_width );

  this->setMaximumHeight(n_rows * m_sprite_height);

}

//---------------------------------------------------------------------------

void QtConnectThreeWidget::DoComputerTurn()

{

  assert(IsComputerTurn());

  const ConnectThree::Move move = m_widget->SuggestMove();

  m_widget->DoMove(move.get<0>(),move.get<1>());

  this->update();

}

//---------------------------------------------------------------------------

int QtConnectThreeWidget::GetActivePlayer() const

{

  return m_widget->GetGame()->GetActivePlayer();

}

//---------------------------------------------------------------------------

const std::string QtConnectThreeWidget::GetVersion()

{

  return "2.0";

}

//---------------------------------------------------------------------------

const std::vector<std::string> QtConnectThreeWidget::GetVersionHistory()

{

  std::vector<std::string> v;

  v.push_back("2011-01-10: version 1.0: initial version");

  v.push_back("2011-04-20: version 2.0: Moved logic to ConnectThreeWidget");

  return v;

}

//---------------------------------------------------------------------------

int QtConnectThreeWidget::GetWinner() const

{

  return m_widget->GetGame()->GetWinner();

}

//---------------------------------------------------------------------------

bool QtConnectThreeWidget::IsComputerTurn() const

{

  return m_widget->IsComputerTurn();

}

//---------------------------------------------------------------------------

void QtConnectThreeWidget::mousePressEvent(QMouseEvent * e)

{

  //Disable clicking if it's the AI's turn

  if (IsComputerTurn()) return;



  const int mouse_x = e->x();

  const int mouse_y = e->y();

  const int x = mouse_x / m_sprite_width;

  const int y = mouse_y / m_sprite_height;

  if (m_widget->GetGame()->CanDoMove(x,y))

  {

    m_widget->DoMove(x,y);

    this->update();

    m_signal_valid_move();

  }

}

//---------------------------------------------------------------------------

void QtConnectThreeWidget::paintEvent(QPaintEvent *)

{

  QPainter painter(this);

  const int n_rows = m_widget->GetGame()->GetRows();

  const int n_cols = m_widget->GetGame()->GetCols();

  for (int y = 0; y!=n_rows; ++y)

  {

    for (int x = 0; x!=n_cols; ++x)

    {

      painter.drawImage(

        x * m_sprite_width,

        y * m_sprite_height,

        GetImage(m_widget->GetGame()->GetSquare(x,y)));

    }

  }

}

//---------------------------------------------------------------------------

const QImage& QtConnectThreeWidget::GetImage(const int sprite) const

{

  switch (sprite)

  {

    case ConnectThree::no_player: return m_empty;

    case ConnectThree::player1  : return m_player1;

    case ConnectThree::player2  : return m_player2;

    case ConnectThree::player3  : return m_player3;

  }

  assert(!"Should not get here");

  throw std::logic_error("Unknown QtConnectThreeWidget::GetImage value");

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

This page has been created by the tool CodeToHtml

(C++) QtConnectThreeWidget

qtconnectthreewidget.h

qtconnectthreewidget.cpp