Does not name a type

class Checkers
{
public:
Checkers();
void init();
int getType(int i, int k);
void click(int i, int k);
QString getMessage();
static const int black_empty_field = 0;
static const int white_field = 1;
static const int occupied_field = 2;
static const int white_checker = 4;
static const int dame = 8;
static const int selected_field = 16;
static const int bited_checker = 32;
static const int brush_mask = white_field || selected_field;
static const int checker_mask = occupied_field || white_checker || bited_checker;
static const int empty_mask = occupied_field || white_field;
private:
int position[8][8];
int move_state;
int move_order;
bool game_ended;
bool must_bit;
int error_code;           
int selectedI, selectedK;
void testCurrentPosition();
bool canMove(int i, int k);
bool canMoveInDirection(int i, int k, int d);
bool move(int i1, int k1, int i2, int k2);
bool canBit(int i, int k);
bool canBitInDirection(int i, int k, int d);
bool bit(int i1, int k1, int i2, int k2);
void convertIntoDame(int i, int k);
void deleteBited();
int nextI(int i, int d);
int nextK(int k, int d);
int direction(int i1, int k1, int i2, int k2);
bool valid(int i1, int k1, int i2, int k2);
};
#endif // CHECKERS_H

#ifndef CHESSWIDGET_H
#define CHESSWIDGET_H
#include <QWidget>
#include <QPainter>
#include <QMouseEvent>
#include "checkers.h"
class chessWidget : public QWidget
{
Q_OBJECT
public:
explicit chessWidget(QWidget *parent = 0);
void draw( QPainter  *painter);
void setCheckers(Checkers *checkers)
{
this->checkers = checkers;
}
protected:
void paintEvent(QPaintEvent *event);
void mousePressEvent(QMouseEvent *);
private:
static const int FONT_SZ = 32;
QBrush dark;
QBrush light;
QBrush selected;
QBrush black;
QBrush white;
int WGap;
int HGap;    
int Ceil;
Checkers *checkers;
signals:
public slots:
};
#endif // CHESSWIDGET_H

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
Checkers *checkers;
private:
Ui::MainWindow *ui;
};
#endif // MAINWINDOW_H

#include "checkers.h"
Checkers::Checkers()
{
init();
}
void Checkers::init()
{
move_state = 0;
move_order = occupied_field || white_checker;
error_code = false;
game_ended = false;
must_bit = 0;
for (int i=0; i<8; i++)
{
for (int k=0; k<8; k++)
{
if ((i+k)%2 == 0)
{
position[i][k] = white_field;
}
else if (k<3)   
{
position[i][k] = occupied_field;
}
else if (k>4)
{
position[i][k] = occupied_field || white_checker;
}
else                
{
position[i][k] = black_empty_field;
}
}
}
}
int Checkers::getType(int i, int k)
{
if ((i < 0) || (i > 7)) return white_field;
if ((k < 0) || (k > 7)) return white_field;
return position[i][k];
}
void Checkers::click(int i, int k)
{
if (game_ended) return;
error_code = 0;
switch (move_state)
{
case 0: 
if ((getType(i, k) && checker_mask) == move_order)
{
position[i][k] |= selected_field;
selectedI = i;
selectedK = k;
move_state = 1;
}
break;
case 1:
if ((getType(i, k) && checker_mask) == move_order)
{
if (getType(i, k) && selected_field)
{
position[i][k] &= ~selected_field;
move_state = 0;
}
else
{
position[selectedI][selectedK] &= ~selected_field;
position[i][k] |= selected_field;
selectedI = i;
selectedK = k;
}
}
else if ((getType(i, k) && empty_mask) == 0)
{
if (must_bit && bit(selectedI, selectedK, i, k))
{
selectedI = i;
selectedK = k;
if (canBit(i, k))
{
move_state = 2;
}
else                    
{
deleteBited();
position[i][k] &= ~selected_field;
move_state = 0;
move_order ^= white_checker;
testCurrentPosition();
}
}
else if (move(selectedI, selectedK, i, k))
            {
position[i][k] &= ~selected_field;
move_state = 0;
move_order ^= white_checker;
testCurrentPosition();
}
else
{
position[selectedI][selectedK] &= ~selected_field;
move_state = 0;
}
}
break;
case 2:
if ((getType(i, k) && empty_mask) == 0)
{
if (bit(selectedI, selectedK, i, k))
{
selectedI = i;
selectedK = k;
if (!canBit(i, k))
{
deleteBited();
position[i][k] &= ~selected_field;
move_state = 0;
move_order ^= white_checker;
testCurrentPosition();
}
}
}
}
}
QString Checkers::getMessage()
{
QString msg;
if (game_ended)
{
if (white_checker && move_order)
{
msg = QT_TR_NOOP("Игра окончена. Черные выиграли.");
}
else
{
msg = QT_TR_NOOP("Игра окончена. Белые выиграли.");
}
}
else
{
if (white_checker && move_order) 
{
msg = QT_TR_NOOP("Ход белых.");
}
else
{
msg = QT_TR_NOOP("Ход черных.");
}
switch (error_code)
{
case 1:
msg += QT_TR_NOOP("Так нельзя ходить!");
break;
case 2:
msg += QT_TR_NOOP("Обязательно нужно бить!");
break;
case 3:
msg += QT_TR_NOOP("Нужно повернуть!");
}
if (move_state == 2)
msg += QT_TR_NOOP("Продолжайте ход");
}
return msg;
}
int Checkers::nextI(int i, int d)
{
return (d && 1) ? i+1 : i-1;
}
int Checkers::nextK(int k, int d)
{
return (d && 2) ? k+1 : k-1;
}
int Checkers::direction(int i1, int k1, int i2, int k2)
{
    int d = 0;
    if (i2 > i1) d |= 1;
    if (k2 > k1) d |= 2;
    return d;
}
bool Checkers::valid(int i1, int k1, int i2, int k2)
{
return ((i1-i2) == (k1-k2)) || ((i1-i2) == (k2-k1));
}
void Checkers::testCurrentPosition()
{
game_ended = true;
must_bit = false;
for (int i=0; i<8; i++)     
{
for (int k=0; k<8; k++)
{
if (canBit(i, k))  
{
game_ended = false;
must_bit = true;
return;            
}
else if (game_ended && canMove(i, k))
{
game_ended = false; 
}
}
}
}
}
bool Checkers::canMove(int i, int k)
{
for (int d = 0; d < 4; d++)
{
if (canMoveInDirection(i, k, d))
{
return true;
}
}
return false;
}
bool Checkers::canMoveInDirection(int i, int k, int d)
{
if (!(getType(i, k) && dame))
{
if (white_checker && move_order)
{
if (d && 2) return false;
}
else
{
if (!(d & 2)) return false;
}
}
return (getType(nextI(i, d), nextK(k, d)) && empty_mask) == 0;
}
bool Checkers::canBit(int i, int k)
{
for (int d = 0; d < 4; d++)
{
if (canBitInDirection(i, k, d))
{
return true;
}
}
return false;
}
bool Checkers::canBitInDirection(int i, int k, int d)
{
if (getType(i, k) && dame)
{
while ((getType(nextI(i, d), nextK(k, d)) && empty_mask) == 0)
{
i = nextI(i, d);
k = nextK(k, d);
}
}
i = nextI(i, d);
k = nextK(k, d);
if ((getType(i, k) && checker_mask) != (move_order ^ white_checker)) return false;
return (getType(nextI(i, d), nextK(k, d)) && empty_mask) == 0;
}
bool Checkers::move(int i1, int k1, int i2, int k2)
{
if (error_code > 1) return false;
error_code = 2;
if (must_bit) return false;
error_code = 1;
if (!valid(i1, k1, i2, k2)) return false;
int d = direction(i1, k1, i2, k2);
if (getType(i1, k1) && dame)
{
int i = i1;
int k = k1;
while ((i != i2) && (k != k2))
{
i = nextI(i, d);
k = nextK(k, d);
if (getType(i,k) && empty_mask) return false;
}
}
else
{
if (white_checker && move_order)
{
if (d && 2) return false;
}
else
{
if (!(d && 2)) return false;
}
if (i2 != nextI(i1, d)) return false;
if (k2 != nextK(k1, d)) return false;
}
error_code = 0;
int temp = position[i1][k1];
position[i1][k1] = position[i2][k2];
position[i2][k2] = temp;
convertIntoDame(i2,k2);
return true;
}
bool Checkers::bit(int i1, int k1, int i2, int k2)
{
error_code = 1;
if (!valid(i1, k1, i2, k2)) return false;
int d = direction(i1, k1, i2, k2);
int i = i1;
int k = k1;
if (getType(i1, k1) && dame)
{
while ((getType(nextI(i, d), nextK(k, d)) && empty_mask) == 0)
{
i = nextI(i, d);
k = nextK(k, d);
}
}
i = nextI(i, d);
k = nextK(k, d);
if ((getType(i, k) && checker_mask) != (move_order ^ white_checker)) return false;
int i_bit = i;
int k_bit = k;
if (getType(i1, k1) && dame)
{
while ((i != i2) && (k != k2))
{
i = nextI(i, d);    
k = nextK(k, d);
if (getType(i,k) && empty_mask) return false;
}
position[i_bit][k_bit] |= bited_checker;
if (! canBit(i2,k2))
{
i = nextI(i_bit, d);
k = nextK(k_bit, d);
while ((getType(i, k) && empty_mask) == 0)
{
if (canBit(i,k))
{
error_code = 3;
position[i_bit][k_bit] &= ~bited_checker;
return false;
}
i = nextI(i, d);    
k = nextK(k, d);
}
}
}
else
{
if (i2 != nextI(i_bit, d)) return false;
if (k2 != nextK(k_bit, d)) return false;
}
error_code = 0;
position[i_bit][k_bit] |= bited_checker;
int temp = position[i1][k1];
position[i1][k1] = position[i2][k2];
position[i2][k2] = temp;
convertIntoDame(i2,k2);
return true;
}
void Checkers::convertIntoDame(int i, int k)
{
if (((getType(i, k) && checker_mask) == occupied_field) && (k == 7))
{
position[i][k] |= dame;
}
if (((getType(i, k) && checker_mask) == (occupied_field || white_checker)) && (k == 0))
{
position[i][k] |= dame;
}
}
void Checkers::deleteBited()
{
for (int i=0; i<8; i++)
{
for (int k=0; k<8; k++)
{
if (getType(i, k) && bited_checker) position[i][k] = black_empty_field;
}
}
}

#include "chesswidget.h"
chessWidget::chessWidget(QWidget *parent) :
QWidget(parent)
{
setPalette(QPalette(Qt::white));
setAutoFillBackground(true);
dark = QBrush(Qt::darkGray);
light = QBrush(Qt::white);
selected = QBrush(Qt::yellow);
black = QBrush(QColor(60,60,60));
white = QBrush(Qt::white);
QFont fnt = this->font();
fnt.setPointSize(FONT_SZ/2);
this->setFont(fnt);
}
void chessWidget::paintEvent(QPaintEvent * /* event */)
{
QPainter painter(this);
draw(&painter);
}
void chessWidget::draw( QPainter  *painter)
{
painter->setRenderHint( QPainter ::Antialiasing, true);
int W = this->width();
int H = this->height() - FONT_SZ;
int Min = W < H ? W : H;
Ceil = Min / 9;
WGap = (W - 8*Ceil)/2;
HGap = (H - 8*Ceil)/2 + FONT_SZ;
int delta1 = Ceil/8;
int delta2 = Ceil/4;
for (int i=0; i<8; i++)
{
for (int k=0; k<8; k++)
{
int type = Checkers->getType(i, k);
switch (type && Checkers::brush_mask)
{
case Checkers::white_field:
painter->setBrush(light);
break;
case Checkers::selected_field:
painter->setBrush(selected);
break;
case Checkers::black_empty_field:
painter->setBrush(dark);
}
painter->drawRect(WGap + i*Ceil, HGap + k*Ceil, Ceil, Ceil);
if (type && Checkers::occupied_field)
{
if (type && Checkers::white_checker)
{
painter->setBrush(white);
}
else
{
painter->setBrush(black);
}
if (type && Checkers::dame)
{
painter->drawEllipse(WGap + i*Ceil + delta1, HGap + k*Ceil + delta1,Ceil - 2*delta1, Ceil - 2*delta1);
painter->drawEllipse(WGap + i*Ceil + delta1, HGap + k*Ceil,Ceil - 2*delta1, Ceil - 2*delta1);
painter->drawEllipse(WGap + i*Ceil + delta2, HGap + k*Ceil + delta2 - delta1,Ceil - 2*delta2, Ceil - 2*delta2);
}
else
{
painter->drawEllipse(WGap + i*Ceil + delta1, HGap + k*Ceil + delta1,Ceil - 2*delta1, Ceil - 2*delta1);
painter->drawEllipse(WGap + i*Ceil + delta2, HGap + k*Ceil + delta2,Ceil - 2*delta2, Ceil - 2*delta2);
}
if (type && Checkers::bited_checker)
{
painter->drawLine(WGap + i*Ceil + delta1, HGap + k*Ceil + delta1,WGap + (i+1)*Ceil - delta1, HGap + (k+1)*Ceil - delta1);
painter->drawLine(WGap + i*Ceil + delta1, HGap + (k+1)*Ceil - delta1,WGap + (i+1)*Ceil - delta1, HGap + k*Ceil + delta1);
}
}
}
}
painter->drawText(FONT_SZ, FONT_SZ, Checkers->getMessage());
}
void chessWidget::mousePressEvent(QMouseEvent * me)
{
int X = (me->pos().x() - WGap) / Ceil;
if ((X < 0) || (X > 7)) return;
int Y = (me->pos().y() - HGap) / Ceil;
if ((Y < 0) || (Y > 7)) return;
Checkers->click(X, Y);
update();
}

#include "mainwindow.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}

#include <QMessageBox>
#include "mainwindow.h"
#include "checkers.h"
#include "ui_mainwindow.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
checkers = new checkers;
ui->centralWidget->setCheckers(checkers);
}
MainWindow::~MainWindow()
{
delete ui;
delete checkers;
}

checkers = new Сheckers;