Разработка программы игры в шашки

 

Нижегородский Государственный Технический Университет

Кафедра ИСУ

Контрольная работа

по дисциплине: «Технология программирования»

Новгород

Данная программа осуществляет игру по 2-м уровням сложности, для игры полей. Предусматривается возможность отката назад на несколько ходов. Поиск хода осуществляется компьютером с помощью ?-? процедуры.

Правила игры

Правила игры в шашки достаточно просты и понятны. Существует клетчатая доска, похожая на шахматную, с белыми (светлыми) и чёрными (тёмными) клетками. Шашки обоих соперников располагаются в несколько рядов, начиная от края доски, на тёмных клетках. Первыми ходят белые. Шашки ходят только по диагонали и, соответственно могут передвигаться только по чёрным квадратам доски. Ходить обычные шашки могут только вперёд. Исключение здесь составляют лишь возможность бить шашки противника назад в некоторых разновидностях правил игры. Бить шашку соперника означает "перепрыгнуть" через неё по диагонали. В этом случае бившая шашка становится за битой, которая в свою очередь снимается с доски. Шашка, достигшая противоположного края доски, превращается в дамку. Дамка может перемещаться как вперёд, так и назад. Цель игры - заблокировать или убрать с доски все шашки противника.

Несмотря на простоту правил, существует масса разновидностей этой игры в мире. Все схожие правила шашек указаны выше. Далее начинаются хоть и местами незначительные, но различия.

Поддавки. Шашки в привычном для нас понимании.

·Доска: 8х8 (как в шахматах);

·Количество шашек у игрока: 12;

·Расположение: первые 3 ряда;

·Бить: произвольное количество шашек в любом направлении;

·Бить назад: разрешено;

·Дамка: передвигается на любое количество полей; если шашка била через поле превращения, она всё равно становится дамкой;

Правила соответствуют русским шашкам. Бить шашки обязательно. Цель игры - как можно быстрее снять с доски все свои шашки. Выигрывает тот, кто первым остался без фигур.

Инструкция пользователя

Для начала игры необходимо выбрать пункт File\level_(выбрать уровень сложности), затем начать играть

После выбора уровня сложности можно начинать играть, открывается игровое поле. Щелкая мышью на соответствующих ячейках пользователь совершает ход, перемещая шашки в указанное положение. Игра ведется с компьютером, поэтому после вашего хода ожидайте хода компьютера. Есть возможность отката игры на несколько ходов назад(CTRL+S,CTRL+N).

Инструкция программиста

В данной программе основным классом является класс LifeWidget, обеспечивающий совершение ходов, как компьютера, так и человека, и Life хранящий информацию о текущей ситуации, а также функции выполняющие ход человека\компьютера и проверяющие на правильность ход шашек\дамок. Основными алгоритмами, исполняющими задачи класса являются ai_mid(), ai_low() здесь осуществляется выбор наилучшего хода и переход к следующей игровой ситуации, mousePressEvent() выполняет обработку нажатий мыши и ход человека, paintEvent() рисует\перерисовывает игровую доску после хода компьютера\человека, также здесь хранится история ходов, которая позволяет откатить игру назад. История\указатели на следующие ходы компьютера хранятся в собственном классе Vector, который включает в себя удобное выполнение операций с одномерным массивом.

Класс Life содержит в себе, во-первых, двумерный массив объектов класс Point(который хранит информацию о положении шашки и её типе) с информацией о расположении на поле шашек, также bool массив cells, хранящий информацию о нажатиях мыши.

Основным является класс ai_Trees, в нём осуществляются алгоритма подсчета ходов, оценка ходов компьютера\человека, построение дерева поиска лучшего хода исходя из оценки функций.

Класс MainWindow это класс интерфейса программы, меню\панель кнопок отката игры\статус строка\вывод центрального виджета игры(игровой доски), также в этом классе осуществляется обработка нажатий\выбора пунктов меню. Кроме того, в классе Field содержится список свободных ячеек для задач класса и, в первую очередь, для генераторов хода.

Весь интерфейс выполнен с использованием Qt-это кросс-платформенный <#"justify">Программа

игра шашки программист алгоритм

Ai_tree.h

#ifndef AI_TREE_H

#define AI_TREE_H

#include "point.h"

#include "Vector.h"namespace std;Tree

{:

~Tree();_t move_x;//текущая Х_t move_y;//текущая У_t move_new_x;//новая Х_t move_new_y;//новая Уrang;// насколько удачный ход для компьютера** points;// игровое поле<Tree*> ai_Trees;// указатели на следующие игровые ситуацииai_move_rating(point**,size_t ,size_t ); // оценка хода компьютераhuman_move_rating(point** points,size_t i,size_t j );// оценка хода человека** ai_copy_swap(point**,size_t ,size_t,size_t ,size_t ); // определение возможных ходов компьютера* first(point** points);// первый уровень игрового дерева* insert_low(Tree*,point**);// новый уровень игрового дерева* insert_mid(Tree*,point**);// новый уровень игрового дереваprint(Tree* ,size_t );// вывод игрового дереваchange_board(point** board,point** new_board);// изменение игрового поля_t num_moves(point** ); //количество ходов компьютера_t num_moves_human(point** board);//количество ходов человекаfrag_comp_bool(point** points,size_t x,size_t y);//проверка на съедание компьютеромfrag_king_ai(point** points,size_t x,size_t y);//проверка на съедание компьютером дамкой

};

#endif

Life.h

#ifndef LIFE_H

#define LIFE_H

#include "point.h"

#include <QtCore>Life : public QObject

{_OBJECT:(QObject *parent = 0);~Life();setGridSize(const QSize &size);// установка размера поляgridSize() const;// возвращение значения размера поляsetCell(const QPoint &pos, bool value);// установка размера поляcell(const QPoint &pos) const;// возвращает активность клеткиCell_King(size_t x,size_t y);// проверка на дамкуmove(size_t x,size_t y,size_t new_x,size_t new_y);// ход человекаfrag(size_t x,size_t y,size_t new_x,size_t new_y);// возможность поеданияfrag_comp(size_t x,size_t y);// ход компьютераfrag_move(size_t x,size_t y,size_t new_x,size_t new_y);// поедание человекfrag_king(size_t x,size_t y);// поедание дамкойmove_ai_king(size_t x,size_t y);// поедание дамкой компьютераrefresh();// сброс данных поляdeleteCells();// удаление данных поляnew_game();// начало новой игрыgame_over();// проверка конца игры**points; // поле**cells;// нажатияtmp;:_t red_count;// кол-во красных_t blue_count;// кол-во синихgridSizeProperty;// размер поля

};

#endif // LIFE_H

LifeWidget.h

#ifndef LIFEWIDGET_H

#define LIFEWIDGET_H

#include <QtGui>

#include "life.h"

#include "ai_tree.h"

#include "Vector.h"

#include "Vector.cpp"

#include "vector"LifeWidget : public QWidget

{_OBJECT:(QWidget *parent = 0);~LifeWidget();setGridSize(const QSize &size);// установка размера поляgridSize() const;//возврат размера поляsetCellSize(int size);//установление размера клеткиcellSize() const;//возврат размера клеткиDraw_Cell(QPainter *painter,QBrush PenBrush,int pen_size,RectBrush,int x0,int y0,int size);//рисование клеткиDraw_Ellipse(QPainter *painter,QBrush PenBrush,int pen_size,RectBrush,int x0,int y0,int size);//рисование шашкиai_low();//низкий уровень сложностиai_mid();//средний уровень сложностиset_game_level(size_t level);//установление режима игры_t cout_moves;//количество ходов*life;_t player;//текущий игрок*game;//дерево ходов**p;//буфер истории ходов<point**> history_moves;//история ходовadd_event_history(point**);//добавление в историюhistory_up();//ход вперёдhistory_down();//ход назадstate_now;//текущее положении истории:minimumSizeHint() const;sizeHint() const;mousePressEvent(QMouseEvent *event);//обработка нажатий мышиpaintEvent(QPaintEvent *event);//рисование и изменение доски:_t game_level;//текущий уровень сложностиclick1;click2;cellSizeProperty;

};

#endif // LIFEWIDGET_H

MainWindow.h

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <QMainWindow>

#include "lifewidget.h"_BEGIN_NAMESPACEQAction;QListWidget;QMenu;QTextEdit;_END_NAMESPACEMainWindow : public QMainWindow

{_OBJECT:();slots:newLetter();save();about();level_mid();level_low();:createActions();createMenus();createToolBars();createStatusBar();*life;*fileMenu;*helpMenu;*fileToolBar;*editToolBar;*newLetterAct;*saveAct;*low;*mid;*aboutAct;*aboutQtAct;*quitAct;

};

#endif

Point.h

#ifndef POINT_H

#define POINT_Hchecker

{= 1,// красная шашка= 2,// синяя шашка= 3,// красная дамка= 4, // синяя дамка= 0,// неходовая клетка= 9,// ходовая,пустая клетка

};point

{x;//Уy;//Хtype;//тип:getX(){return x;}getY(){return y;}getT(){return type;}setT(int t){type=t;}(){x=0; y=0; type=0;}(const point& p)

{>x=p.x;>y=p.y;>type=p.type;

}(int x, int y, int type)

{>x = x;>y = y;>type = type;

}operator == (const point & p )

{( x==p.x && y==p.y && type==p.type )return true;return false;

}

};

#endif

Vector.h

#ifndef VECTOR_H

#define VECTOR_H

#include <iostream>namespace std;<class T>Vector

{* V;_t n;_t capacity_m;:(size_t=0);(const Vector&);_t size();reserve(size_t );_t begin();_t end();_t capacity();& erase(size_t);swap (Vector& );push_back(T);resize(size_t);

~Vector();& operator[](size_t);

};

#endif

ai_tree.cpp

#include <iostream>

#include "Vector.h"

#include "point.h"

#include "life.h"

#include "ai_tree.h"

#include "Vector.cpp"* Tree::first(point** board)

{* pv=new Tree;>points= new point*[8];(size_t i = 0; i < 8; i++)>points[i]= new point[8];>change_board(pv->points,board);>rang=0;>ai_Trees.resize(num_moves(board));pv;

}::~Tree()

{(size_t i=0;i<ai_Trees.size();i++)ai_Trees[i];_Trees=0;

}* Tree::insert_low(Tree *root,point** points)

{* pTree=NULL;_t num=0;>ai_Trees.resize(pTree->num_moves(points));(size_t i = 0; i < 8; i++)

{(size_t j = 0; j < 8; j++)

{(points[i][j].getT()==RED)

{((j+1)<8&&(i+1)<8)

{((points[i+1][j+1].getT()==EMPTYCELL||[i+1][j+1].getT()==BLUE)&&

(root->ai_Trees.size()>num))

{=new Tree;>points=ai_copy_swap(points,j,i,j+1,i+1);>move_x=i;>move_y=j;>move_new_x=i+1;>move_new_y=j+1;>rang=ai_move_rating(points,i,j);>ai_Trees.resize(pTree->num_moves(points));>ai_Trees[num++]=pTree;

}

}((j-1)<8&&(i+1)<8)

{((points[i+1][j-1].getT()==EMPTYCELL||[i+1][j-1].getT()==BLUE)&&

(root->ai_Trees.size()>num))

{=new Tree;>points=ai_copy_swap(points,j,i,j-1,i+1);>rang=ai_move_rating(points,i,j);>move_x=i;>move_y=j;>move_new_x=i+1;>move_new_y=j-1;>ai_Trees.resize(pTree->num_moves(points));>ai_Trees[num++]=pTree;

}

}

}(points[i][j].getT()==REDKING&&_king_ai(points,i,j))

{=new Tree;>rang=ai_move_rating(points,i,j);>move_x=i;>move_y=j;>ai_Trees.resize(pTree->num_moves(points));>ai_Trees[num++]=pTree;

}

}

}root;

}* Tree::insert_mid(Tree *root,point** points)

{* pTree=NULL;_t num=0;>ai_Trees.resize(pTree->num_moves_human(points));(size_t i = 0; i < 8; i++)

{(size_t j = 0; j < 8; j++)

{(points[i][j].getT()==BLUE)

{((j-1)>0&&(j-1)<8&&(i-1)<8&&(i-1)>0)

{((points[i-1][j-1].getT()==EMPTYCELL||[i-1][j-1].getT()==RED)&&

(root->ai_Trees.size()>num))

{=new Tree;>points=ai_copy_swap(points,j,i,j-1,i-1);>move_x=i;>move_y=j;>move_new_x=i-1;>move_new_y=j-1;>rang=human_move_rating(points,i,j);>ai_Trees.resize(0);>ai_Trees[num++]=pTree;

}

}((j+1)>0&&(j+1)<8&&(i-1)<8&&(i-1)>0)

{((points[i-1][j+1].getT()==EMPTYCELL||[i-1][j+1].getT()==RED)&&

(root->ai_Trees.size()>num))

{=new Tree;>points=ai_copy_swap(points,j,i,j+1,i-1);>rang=human_move_rating(points,i,j);>move_x=i;>move_y=j;>move_new_x=i-1;>move_new_y=j+1;>ai_Trees.resize(0);>ai_Trees[num++]=pTree;

}

}

}(points[i][j].getT()==BLUEKING&&frag_king_ai(points,i,j))

{=new Tree;>rang=ai_move_rating(points,i,j);>move_x=i;>move_y=j;>move_new_x=i+1;>move_new_y=j-1;>ai_Trees.resize(pTree->num_moves(points));>ai_Trees[num++]=pTree;

}

}

}root;

}Tree::print(Tree* root,size_t level)

{(root)

{(size_t i=0;i<root->ai_Trees.size();i++)(root->ai_Trees[i],level+1);(size_t i=0;i<level;i++)<<" ";<<root->rang<<endl;

}

}Tree::change_board(point** board,point** new_board)

{(size_t i = 0; i < 8; i++)(size_t j = 0; j < 8; j++)[i][j]=new_board[i][j];

}_t Tree::num_moves_human(point** board)

{_t num=0;(size_t i = 0; i < 8; i++)

{(size_t j = 0; j < 8; j++)

{(board[i][j].getT()==BLUE)

{((j-1)>0&&(j-1)<8&&(i-1)<8&&(i-1)>0)((board[i-1][j-1].getT()==EMPTYCELL||[i-1][j-1].getT()==RED)&&[i-1][j-1].getT()!=RED) num++;((j+1)>0&&(j+1)<8&&(i-1)<8&&(i-1)>0)((board[i-1][j+1].getT()==EMPTYCELL||[i-1][j+1].getT()==RED)&&[i-1][j+1].getT()!=RED) num++;

}(board[i][j].getT()==BLUEKING)(frag_king_ai(board,i,j)) num++;

}

}num;

}_t Tree::num_moves(point** board)

{_t num=0;(size_t i = 0; i < 8; i++)

{(size_t j = 0; j < 8; j++)

{(board[i][j].getT()==RED)

{((j+1)<8&&(i+1)<8)((board[i+1][j+1].getT()==EMPTYCELL||[i+1][j+1].getT()==BLUE)&&[i+1][j+1].getT()!=RED)++;((j-1)<8&&(i+1)<8)((board[i+1][j-1].getT()==EMPTYCELL||[i+1][j-1].getT()==BLUE)&&[i+1][j-1].getT()!=RED)++;

}(board[i][j].getT()==REDKING)(frag_king_ai(board,i,j)) num++;

}

}num;

}** Tree::ai_copy_swap(point** board,size_t pos_x,size_t pos_y,size_t new_pos_x,size_t new_pos_y)

{** tmp;tmp_1;= new point*[8];(size_t i = 0; i < 8; i++)

{[i]= new point[8];(size_t j = 0; j < 8; j++)

{[i][j]=board[i][j];

}

}_1=tmp[pos_y][pos_x];[pos_y][pos_x]=tmp[new_pos_y][new_pos_x];[new_pos_y][new_pos_x]=tmp_1;tmp;

}Tree::ai_move_rating(point** points,size_t i,size_t j )

{rank=0;(points[i][j].getT()==REDKING) rank+=25;(frag_king_ai(points,i,j)) rank+=100;(frag_comp_bool(points,i,j)) rank+=50;((j-1)<8&&(j+1)<8&&(i+1)<8)

{(points[i+1][j+1].getT()==EMPTYCELL||points[i+1][j-1].getT()==EMPTYCELL) rank+=15;

}((i+1)<8&&(i+2)<8&&(j-1)<8&&(j+2)<8)

{(points[i+1][j+1].getT()==BLUE&&points[i+2][j+2].getT()==BLUE) rank-=50;

}((i-1)<8&&(j-1)<8&&(j-2)<8&&(i+2)<8)

{(points[i+1][j-1].getT()==BLUE&&points[i+2][j-2].getT()==BLUE) rank-=50;

}((i+1)<8&&(i+2)<8&&(j+1)<8)

{(points[i+1][j+1].getT()==EMPTYCELL&&points[i+2][j].getT()==BLUE) rank+=3;

}((i+1)<8&&(i+2)<8&&(j-1)<8&&(j+2)<8)

{(points[i+1][j-1].getT()==EMPTYCELL&&points[i+2][j+2].getT()==BLUE) rank+=3;

}((i+1)<8&&(i+2)<8&&(j-1)<8&&((j-2)<8||(j+2)<8))

{(points[i+1][j-1].getT()==BLUE&&(points[i+2][j-2].getT()==EMPTYCELL||[i+2][j+2].getT()==EMPTYCELL)) rank+=50;

}rank;

}Tree::human_move_rating(point** points,size_t i,size_t j )

{rank=0;(points[i][j].getT()==BLUEKING) rank+=5;(frag_king_ai(points,i,j)) rank+=100;((j+1)<8&&(j-1)<8&&(i-1)<8)

{(points[i-1][j-1].getT()==EMPTYCELL||points[i-1][j+1].getT()==EMPTYCELL) rank++;

}((i-1)<8&&(i-2)<8&&(j+1)<8&&(j-2)<8)

{(points[i-1][j-1].getT()==RED&&points[i-2][j-2].getT()==RED) rank-=5;

}((i+1)<8&&(j+1)<8&&(j+2)<8&&(i-2)<8)

{(points[i-1][j+1].getT()==RED&&points[i-2][j+2].getT()==BLUE) rank-=5;

}((i-1)<8&&(i-2)<8&&(j-1)<8)

{(points[i-1][j-1].getT()==EMPTYCELL&&points[i-2][j].getT()==RED) rank+=20;

}((i-1)<8&&(i-2)<8&&(j+1)<8&&(j-2)<8)

{(points[i-1][j+1].getT()==EMPTYCELL&&points[i-2][j-2].getT()==RED) rank+=20;

}((i-1)<8&&(i-2)<8&&(j+1)<8&&(j+2)<8)

{(points[i-1][j+1].getT()==RED&&(points[i-2][j+2].getT()==EMPTYCELL||[i-2][j-2].getT()==EMPTYCELL)) rank+=50;

}rank;

}Tree::frag_king_ai(point** points,size_t x,size_t y)

{(points[x][y].getT()!=REDKING) return false;(size_t i=1;i<8;i++)

{((x+i+1)<8&&(y+i+1)<8)((points[x+i][y+i].getT()==BLUE||[x+i][y+i].getT()==BLUEKING)

&&points[x+i+1][y+i+1].getT()==EMPTYCELL)true;((x-i-1)>=0&&(y-i-1)>=0&&(x-i-1)<8&&(y-i-1)<8)((points[x-i][y-i].getT()==BLUE||[x-i][y-i].getT()==BLUEKING)

&&points[x-i-1][y-i-1].getT()==EMPTYCELL)true;((x+i+1)<8&&(y-i-1)<8&&(x-i-1)>=0)((points[x+i][y-i].getT()==BLUE||[x+i][y-1].getT()==BLUEKING)

&&points[x+i+1][y-i-1].getT()==EMPTYCELL)true;((x-i-1)>=0&&(x-i-1)<8&&(y+i+1)<8)((points[x-i][y+i].getT()==BLUE||[x-i][y+i].getT()==BLUEKING)

&&points[x-i-1][y+i+1].getT()==EMPTYCELL)true;

}false;

}Tree::frag_comp_bool(point** points,size_t x,size_t y)

{((x+1)<8&&(x+2)<8&&(y-1)<8&&(y-2)<8)(points[x+1][y-1].getT()==BLUE&&[x+2][y-2].getT()==EMPTYCELL)true;((x+1)<8&&(x+2)<8&&(y+1)<8&&(y+2)<8)(points[x+1][y+1].getT()==BLUE&&[x+2][y+2].getT()==EMPTYCELL)true;false;

}

Life.cpp

#include <QtCore>

#include "life.h"

#include <iostream>namespace std;::Life(QObject *parent)

: QObject(parent)

{= 0;= 0;(QSize(8, 8));

}::~Life()

{

}Life::new_game()

{(size_t i = 0; i < gridSize().width(); i++)

{(size_t j = 0; j < gridSize().height(); j++)

{[i][j] = false;(i<=2&&(i+j)&1)[i][j]=point(i,j,RED);if(i>=5&&i<=7&&(i+j)&1)[i][j]=point(i,j,BLUE);if(i>=3&&i<=4&&(i+j)&1)[i][j]=point(i,j,EMPTYCELL);if(!(i+j)&1)[i][j]=point(i,j,WHITECELL);

}

}

}Life::game_over()

{_count=0;_count=0;(size_t i = 0; i < gridSize().width(); i++)

{(size_t j = 0; j < gridSize().height(); j++)

{(points[i][j].getT()==RED) red_count++;if (points[i][j].getT()==BLUE)_count++;if (points[i][j].getT()==BLUEKING)_count++;if (points[i][j].getT()==REDKING)_count++;

}

}(red_count==0)true;if(blue_count==0)true;false;

}Life::setGridSize(const QSize &size)

{(cells != 0) {();

}= size;= new bool*[gridSize().width()];= new point*[gridSize().width()];(size_t i = 0; i < gridSize().width(); i++)

{[i] = new bool[gridSize().height()];[i]= new point[gridSize().width()];(size_t j = 0; j < gridSize().height(); j++)

{[i][j] = false;(i<=2&&(i+j)&1)[i][j]=point(i,j,RED);if(i>=5&&i<=7&&(i+j)&1)[i][j]=point(i,j,BLUE);if(i>=3&&i<=4&&(i+j)&1)[i][j]=point(i,j,EMPTYCELL);if(!(i+j)&1)[i][j]=point(i,j,WHITECELL);

}

}

}Life::gridSize() const

{gridSizeProperty;

}Life::frag_comp(size_t x,size_t y)

{((x+1)<8&&(x+2)<8&&(y-1)<8&&(y-2)<8)

{((points[x+1][y-1].getT()==BLUE||[x+1][y-1].getT()==BLUEKING)&&[x+2][y-2].getT()==EMPTYCELL)

{(x,y,x+2,y-2);[(x+x+2)/2][(y+y-2)/2].setT(EMPTYCELL);_comp(x+2,y-2);true;

}

}((x+1)<8&&(x+2)<8&&(y+1)<8&&(y+2)<8)

{((points[x+1][y+1].getT()==BLUE

||points[x+1][y-1].getT()==BLUEKING)

&&points[x+2][y+2].getT()==EMPTYCELL)

{(x,y,x+2,y+2);[(x+x+2)/2][(y+y+2)/2].setT(EMPTYCELL);_comp(x+2,y+2);true;

}

}false;

}Life::frag(size_t x,size_t y,size_t new_x,size_t new_y)

{(points[new_x][new_y].getT()==EMPTYCELL&&[(x+new_x)/2][(y+new_y)/2].getT()==RED||[(x+new_x)/2][(y+new_y)/2].getT()==REDKING)true;false;

}Life::frag_move(size_t x,size_t y,size_t new_x,size_t new_y)

{(points[x][y].getT()==BLUE||points[x][y].getT()==BLUEKING)

{(points[x][y].getT()==BLUEKING)

{(size_t i=1 ;i<8;i++)

{((x+i)<8&&(y+i)<8)

{(points[x+i][y+i].getT()==RED||[x+i][y+i].getT()==REDKING)

{(x,y,new_x,new_y);[x+i][y+i].setT(EMPTYCELL);true;

}

}((x-i)<8&&(y-i)<8)

{(points[x-i][y-i].getT()==RED||[x-i][y-i].getT()==REDKING)

{(x,y,new_x,new_y);[x-i][y-i].setT(EMPTYCELL);true;

}

}((x+i)<8&&(y-i)<8)

{(points[x+i][y-i].getT()==RED||[x+i][y-i].getT()==REDKING)

{(x,y,new_x,new_y);[x+i][y-i].setT(EMPTYCELL);true;

}

}((x-i)<8&&(y+i)<8)

{(points[x-i][y+i].getT()==BLUE&&[x-i][y+i].getT()==EMPTYCELL)

{(x,y,new_x,new_y);[x-i][y+i].setT(EMPTYCELL);true;

}

}

}

}if(points[x][y].getT()==BLUE)

{(x,y,new_x,new_y);[(x+new_x)/2][(y+new_y)/2].setT(EMPTYCELL);((new_y-2)>0&&(new_y-2)<8&&(new_x-2)<8&&(new_x-2)>=0)(frag(new_x,new_y,new_x-2,new_y-2))_move(new_x,new_y,new_x-2,new_y-2);((new_y+2)>0&&(new_y+2)<8&&(new_x-2)<8&&(new_x-2)>=0)(frag(new_x,new_y,new_x-2,new_y+2))_move(new_x,new_y,new_x-2,new_y+2);true;

}

}false;

}Life::frag_king(size_t x,size_t y)

{(points[x][y].getT()!=REDKING) return false;(size_t i=1;i<8;i++)

{((x+i+1)<8&&(y+i+1)<8)

{(points[x+i][y+i].getT()==RED) continue;((points[x+i][y+i].getT()==BLUE||[x+i][y+i].getT()==BLUEKING)&&[x+i-1][y+i-1].getT()!=BLUE&&[x+i+1][y+i+1].getT()==EMPTYCELL)

{(x,y,x+i+1,y+i+1);[x+i][y+i].setT(EMPTYCELL);_king(x+i+1,y+i+1);true;

}

}((x-i-1)<8&&(y-i-1)<8)

{(points[x-i][y-i].getT()==RED) continue;((points[x-i][y-i].getT()==BLUE||[x-i][y-i].getT()==BLUEKING)&&[x-i-1][y-i-1].getT()!=BLUE

&&points[x-i-1][y-i-1].getT()==EMPTYCELL)

{(x,y,x-i-1,y-i-1);[x-i][y-i].setT(EMPTYCELL);_king(x-i-1,y-i-1);true;

}

}((x+i+1)<8&&(y-i-1)<8)

{(points[x+i][y-i].getT()==RED) continue;((points[x+i][y-i].getT()==BLUE||[x+i][y-i].getT()==BLUEKING)&&[x+i-1][y-i-1].getT()!=BLUE

&&points[x+i+1][y-i-1].getT()==EMPTYCELL)

{(x,y,x+i+1,y-i-1);[x+i][y-i].setT(EMPTYCELL);_king(x+i+1,y-i-1);true;

}

}((x-i-1)<8&&(y+i+1)<8)

{(points[x-i][y+i].getT()==RED) continue;((points[x-i][y+i].getT()==BLUE||[x-i][y+i].getT()==BLUEKING)&&[x-i-1][y+i-1].getT()!=BLUE

&&points[x-i-1][y+i+1].getT()==EMPTYCELL)

{(x,y,x-i-1,y+i+1);[x-i][y+i].setT(EMPTYCELL);_king(x-i-1,y+i+1);true;

}

}

}false;

}Life::refresh()

{(size_t i = 0; i < gridSize().width(); i++)(size_t j = 0; j < gridSize().height(); j++)[i][j]=false;

}Life::move_ai_king(size_t x,size_t y)

{(points[x][y].getT()==REDKING)

{((x-1)>0&&(y-1)<8&&(x-1)<8&&(x-1)>0)(points[x-1][y-1].getT()==EMPTYCELL&&[x-1][y-1].getT()!=RED)

{(x,y,x-1,y-1);true;

}((y+1)>0&&(y+1)<8&&(x-1)<8&&(x-1)>0)(points[x-1][y+1].getT()==EMPTYCELL&&[x-1][y+1].getT()!=RED)

{(x,y,x-1,y+1);true;

}

}false;

}Life::move(size_t x,size_t y,size_t new_x,size_t new_y)

{buf;=points[new_x][new_y];[new_x][new_y]=points[x][y];[x][y]=buf;true;

}Life::setCell(const QPoint &pos, bool value)

{(gridSize().width() > pos.x() &&().height() > pos.y())

{[pos.x()][pos.y()] = value;

}

}Life::cell(const QPoint &pos) const

{(gridSize().width() > pos.x() &&().height() > pos.y())

{cells[pos.x()][pos.y()];

}false;

}Life::Cell_King(size_t x,size_t y)

{(points[x][y].getT()==RED&&x==7)

{[x][y].setT(REDKING);true;

}if(points[x][y].getT()==BLUE&&x==0)

{[x][y].setT(BLUEKING);true;

}false;

}Life::deleteCells()

{(size_t i = 0; i < gridSize().width(); i++)

{[] cells[i];[] points[i];

}[] cells;[] points;= 0;= 0;

}

LifeWidget.cpp

#include <QtGui>

#include "life.h"

#include "lifewidget.h"

#include "ai_tree.h"

#include "point.h"

#include <iostream>

#include "mainwindow.h"namespace std;::LifeWidget(QWidget *parent)

: QWidget(parent)

{= new Life(this);=BLUE;_moves=1;=FALSE;=FALSE;_now=-1;_level=3;(70);(QSize(8, 8));=game->first(life->points);= new point*[8];(size_t i = 0; i < 8; i++)

{[i] = new point[8];(size_t j = 0; j < 8; j++)[i][j]=point();

}>change_board(p,life->points);_event_history(p);

}::~LifeWidget()

{(size_t i = 0; i < 8; i++)p[i];

}LifeWidget::add_event_history(point** new_move)

{** tmp_2=new_move;_2 = new point*[8];(size_t i = 0; i < 8; i++)

{_2[i] = new point[8];(size_t j = 0; j < 8; j++)_2[i][j]=new_move[i][j];

}_moves.push_back(tmp_2);_now++;

}LifeWidget::set_game_level(size_t level)

{(level==1)_level=1;if(level==0)_level=0;

}LifeWidget::history_up()

{_now++;(state_now>=history_moves.size())

{_now--;;

}

{**p=history_moves[state_now];>change_board(life->points,p);=BLUE;();

}

}LifeWidget::history_down()

{_now--;(state_now<=0)

{_now++;;

}

{**p=history_moves[state_now];>change_board(life->points,p);=BLUE;();

}

}LifeWidget::setGridSize(const QSize &size)

{>setGridSize(size);();();

}LifeWidget::gridSize() const

{life->gridSize();

}LifeWidget::setCellSize(int size)

{= size;();();

}LifeWidget::cellSize() const

{cellSizeProperty;

}LifeWidget::minimumSizeHint() const

{QSize(gridSize().width() * cellSize() , gridSize().height() * cellSize());

}LifeWidget::sizeHint() const

{minimumSizeHint();

}LifeWidget::mousePressEvent(QMouseEvent *event)

{(!(game_level==1||game_level==0)) return;pos = QPoint(event->pos().x() / cellSize(), event->pos().y() / cellSize());(player==BLUE)

{((pos.y()+pos.x())&1&&(life->points[pos.y()][pos.x()].getT()==BLUE||>points[pos.y()][pos.x()].getT()==BLUEKING))

{(event->button() == Qt::RightButton)

{=false;=false;>refresh();();;

}

}(click1==false&&(pos.y()+pos.x())&1&&(life->points[pos.y()][pos.x()].getT()==BLUE||>points[pos.y()][pos.x()].getT()==BLUEKING))

{=true;(event->button() == Qt::LeftButton && !life->cell(pos)&&click1)

{>setCell(pos, true);click(pos.y(),pos.x(),life->points[pos.y()][pos.x()].getT());>tmp=click;=true;();;

}

}if (event->button() == Qt::LeftButton&&!life->cell(pos)&&click1&&click2&&(pos.y()+pos.x())&1

&&life->points[pos.y()][pos.x()].getT()==EMPTYCELL)

{>setCell(pos, true);(life->points[life->tmp.getX()][life->tmp.getY()].getT()==BLUEKING)

{>change_board(p,life->points);_event_history(p);(life->frag_move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x()))

{>refresh();=false;=false;=RED;();;

}

{>move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());>refresh();=false;=false;=RED;();;

}

}(life->frag(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x()))

{>change_board(p,life->points);_event_history(p);((life->tmp.getX()-2)==pos.y()&&((life->tmp.getY()-2)==pos.x()||(life->tmp.getY()+2)==pos.x()))

{>frag_move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());>refresh();=false;=false;=RED;();(life->game_over())

{>new_game();=BLUE;;

}

}

{>refresh();=false;=false;=BLUE;

}

}

{>change_board(p,life->points);_event_history(p);((life->tmp.getX()-1)==pos.y()&&((life->tmp.getY()-1)==pos.x()||(life->tmp.getY()+1)==pos.x()))

{>move(life->tmp.getX(),life->tmp.getY(),pos.y(),pos.x());>refresh();=false;=false;=RED;

}

{=false;=false;=BLUE;>refresh();

}

}

}

}

}LifeWidget::Draw_Cell(QPainter *painter,QBrush PenBrush,int pen_size,QBrush RectBrush,int x0,int y0,int size)

{>setRenderHint(QPainter::Antialiasing);>setPen(QPen(PenBrush,pen_size, Qt::SolidLine));>setBrush(RectBrush);>drawRect(x0, y0, size, size);

}LifeWidget::Draw_Ellipse(QPainter *painter,QBrush PenBrush,int pen_size,QBrush RectBrush,int x0,int y0,int size)

{>setRenderHint(QPainter::Antialiasing);>setPen(QPen(PenBrush,pen_size, Qt::SolidLine));>setBrush(RectBrush);>drawEllipse(x0, y0, size, size);

}LifeWidget::ai_low()

{(player==RED)

{>insert_low(game,life->points);max=game->ai_Trees[0]->rang;ii=0;(size_t i=0;i<game->ai_Trees.size();i++)

{(game->ai_Trees[i]->rang>max)

{=i;=game->ai_Trees[i]->rang;

}

}=game->ai_Trees[ii];(game->frag_king_ai(life->points,game->move_x,game->move_y))

{>frag_king(game->move_x,game->move_y);=BLUE;();;

}if(life->frag_comp(game->move_x,game->move_y))

{=BLUE;();;

}if(life->move_ai_king(game->move_x,game->move_y))

{=BLUE;();;

}

{>move(game->move_x,game->move_y,game->move_new_x,game->move_new_y);=BLUE;();;

}=BLUE;();

}

}LifeWidget::ai_mid()

{(player==RED)

{* tmp=game;_moves++;>insert_low(game,life->points);maxI=game->ai_Trees[0]->rang;iii=0;(size_t i=0;i<game->ai_Trees.size();i++)

{(game->ai_Trees[i]->rang>maxI)

{=i;=game->ai_Trees[i]->rang;

}

}(game->frag_king_ai(life->points,game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{>frag_king(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y);=BLUE;();;

}if(life->frag_comp(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{=BLUE;();;

}if(life->move_ai_king(game->ai_Trees[iii]->move_x,game->ai_Trees[iii]->move_y))

{=BLUE;();;

}(size_t i=0;i<game->ai_Trees.size();i++)>insert_mid(game->ai_Trees[i],game->ai_Trees[i]->points);<int> childs_sum(game->ai_Trees.size());(size_t i=0;i<game->ai_Trees.size();i++)(size_t j=0;j<game->ai_Trees[i]->ai_Trees.size();j++)_sum[i]+=game->ai_Trees[i]->ai_Trees[j]->rang;ii=0;max=childs_sum[0];(size_t i=0;i<childs_sum.size();i++)(childs_sum[i]>max)

{=i;=childs_sum[i];

}=game->ai_Trees[ii];(1)

{>move(game->move_x,game->move_y,game->move_new_x,game->move_new_y);=BLUE;();;

}=BLUE;();

}

}LifeWidget::paintEvent(QPaintEvent* /*event*/)

{p(this);(game_level==1) ai_mid();if(game_level==0) ai_low();(life->game_over())

{>new_game();=BLUE;;

}(int i = 0; i < gridSize().width(); i++) //KING(int j = 0; j < gridSize().height(); j++)>Cell_King(i,j);(int i = 0; i < gridSize().width(); i++) //рисование поля

{(int j = 0; j < gridSize().height(); j++)

{((i+j)&1)

{_Cell(&p,Qt::black,0,Qt::gray,i * cellSize(),j * cellSize(),cellSize());(life->points[j][i].getT()==RED)

{_Ellipse(&p,Qt::black,2,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==BLUE)

{_Ellipse(&p,Qt::black,2,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==REDKING)

{_Ellipse(&p,Qt::green,4,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==BLUEKING)

{_Ellipse(&p,Qt::green,4,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

}if(life->points[j][i].getT()==WHITECELL)

{_Cell(&p,Qt::black,0,Qt::white,i * cellSize(),j * cellSize(),cellSize());(int i = 0; i < gridSize().width(); i++) //рисование желтой клетки(int j = 0; j < gridSize().height(); j++)(life->cell(QPoint(i, j))&&(i+j)&1)

{_Cell(&p,Qt::yellow,6,Qt::gray,i * cellSize(),j * cellSize(),cellSize());(life->points[j][i].getT()==RED)

{_Ellipse(&p,Qt::black,2,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==BLUE)

{_Ellipse(&p,Qt::black,2,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==REDKING)

{_Ellipse(&p,Qt::green,4,Qt::red,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}if(life->points[j][i].getT()==BLUEKING)

{_Ellipse(&p,Qt::green,4,Qt::blue,i * cellSize()+5,j * cellSize()+5,cellSize()-10);

}

}();

}

MainWindow.cpp

#include <QtGui>

#include "mainwindow.h"

#include "lifewidget.h"

#include "ai_tree.h"

#include "point.h"::MainWindow()

{scroll;= new LifeWidget(&scroll);(life);.show();>show();>setCellSize(70);();();();();(tr("Checkers"));(true);

}MainWindow::newLetter()

{>history_down();();

}MainWindow::save()

{>history_up();();

}MainWindow::about()

{::about(this, tr("About Checkers"),("<b> Checkers //</b>"

"<b> NN,2010</b>"));

}MainWindow::level_mid()

{>set_game_level(1);

}MainWindow::level_low()

{>set_game_level(0);

}MainWindow::createActions()

{= new QAction(QIcon("save.png"), tr("&Back"),);>setShortcuts(QKeySequence::New);>setStatusTip(tr("Back_move"));(newLetterAct, SIGNAL(triggered()), this, SLOT(newLetter()));= new QAction(QIcon("new.png"), tr("&Forward"), this);>setShortcuts(QKeySequence::Save);>setStatusTip(tr("Forward_move"));(saveAct, SIGNAL(triggered()), this, SLOT(save()));= new QAction(QIcon("low.png"),tr("low_level"), this);>setStatusTip(tr("low_level"));(low, SIGNAL(triggered()), this, SLOT(level_low()));= new QAction(QIcon("mid.png"),tr("&mid_level"), this);>setStatusTip(tr("mid_level"));(mid, SIGNAL(triggered()), this, SLOT(level_mid()));= new QAction(tr("&Quit"), this);>setShortcuts(QKeySequence::Quit);>setStatusTip(tr("Quit the application"));(quitAct, SIGNAL(triggered()), this, SLOT(close()));= new QAction(tr("&About"), this);>setStatusTip(tr("Show the application's About box"));(aboutAct, SIGNAL(triggered()), this, SLOT(about()));= new QAction(tr("About &Qt"), this);>setStatusTip(tr("Show the Qt library's About box"));(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));

}MainWindow::createMenus()

{= menuBar()->addMenu(tr("&File"));>addAction(newLetterAct);>addAction(saveAct);>addSeparator();>addAction(low);>addAction(mid);>addSeparator();>addAction(quitAct);()->addSeparator();= menuBar()->addMenu(tr("&Help"));>addAction(aboutAct);>addAction(aboutQtAct);

}MainWindow::createToolBars()

{= addToolBar(tr("File"));>addAction(newLetterAct);>addAction(saveAct);

}MainWindow::createStatusBar()

{()->showMessage(tr("Ready"));

}

Vector.cpp

#include <iostream>

#include "Vector.h"namespace std;<class T><T>::~Vector()

{[] V;=0;

}<class T>_t Vector<T>::size()

{n;

}<class T>_t Vector<T>::begin()

{0;

}<class T>_t Vector<T>::end()

{n;

}<class T>_t Vector<T>::capacity()

{capacity_m;

}<class T>Vector<T>::swap(Vector& Vect)

{::swap (V, Vect.V);::swap (n, Vect.n);::swap (capacity_m, Vect.capacity_m);

}<class T><T>::Vector(const Vector& Vect)

{=Vect.n;_m=Vect.capacity_m;=new T[n];(size_t i=0;i<n;i++)

(*this)[i]=Vect.V[i];

}<class T>& Vector<T>::operator [](size_t i)

{(i<n) return V[i];out_of_range("vector index");

}<class T><T>::Vector(size_t new_size)

{=new_size;_m=new_size;=new T[new_size];(size_t i=0;i<new_size;i++)

(*this)[i]=T();

}<class T><T>& Vector<T> ::erase(size_t k)

{(k>=n) throw out_of_range("vector index");buf=*this;-;(size_t i=0;i<n;i++)(i!=k)(*this)[i]=buf[i];

{

(*this)[i]=buf[i+1];++;

}*this;

}<class T>Vector<T> ::push_back(T new_item)

{( size() == capacity() ) reserve ( capacity() * 2 );

(*this)[n++] = new_item;

}<class T>Vector<T>::resize(size_t new_size)

{( new_size <= size() )

{=new_size;;

}( new_size > capacity() )( new_size * 2 );[] V;=new T[new_size];( n != new_size )

(*this)[n++] = T();

}<class T>Vector<T>::reserve (size_t new_cap)

{(new_cap <= capacity() ) return;buf;.V = new T[new_cap];.capacity_m = new_cap;.n = n;

(size_t i=0; i<n; ++i)[i] = (*this)[i];.swap (*this);

}

Результаты работы программы

Нижегородский Государственный Технический Университет Кафедра ИСУ Контрольная работа по дисциплине:

Больше работ по теме: