Разработка игры "Крестики-нолики"

МИНИСТЕРСТВО
ОБРАЗОВАНИЯ И НАУКИ

РОССИЙСКОЙ
ФЕДЕРАЦИИ

ФЕДЕРАЛЬНОЕ
АГЕНСТВО ПО ОБРАЗОВАНИЮ

КУРГАНСКИЙ
ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ

Кафедра
автоматизации производственных процессов

Курсовая
работа

Расчетно-пояснительная
записка.

Дисциплина: Программирование
и основы алгоритмизации

«Разработка
игры «Крестики-нолики»

Студент: Иванов П. С.

Группа: Т-2144

Руководитель: Скобелев И.
В.

Комиссия__________________

Оценка____________________

Дата защиты_______________

Курган, 2006

Введение

Стремительное развитие
компьютерной техники в последние годы, появление мощнейших графических
ускорителей и центральных процессоров способствовало не менее бурному развитию
индустрии компьютерных игр. Выдающиеся разработки этой отрасли – это сложнейшие
программы, как правило, с очень высокими требованиями к аппаратной части
компьютера. Однако для возможности отдохнуть в перерыве от выполнения
какой-либо работы оператору компьютера не всегда требуется новейшая
компьютерная игра, а зачастую использовать её не позволяет маломощное
оборудование офисного компьютера. Именно этой цели – отдыху от монотонной
работы служит разработанная в рамках данного курсового проекта программа.

1. Техническое задание

Игровое поле представлено
25 клетками, как показано на рис.1.

Рис. 1. Игровое поле
после запуска игры

Игра рассчитана на 2-х
игроков, которые по очереди наводят указатель мыши на соответствующую клетку
игрового поля и щелчком левой кнопки мыши ставят в ней крестик или нолик. Первый
ход совершает пользователь, играющий крестиками. Победа присуждается игроку,
который выстроит в линию последовательность четырех значков Х или О - по горизонтали,
вертикали или диагонали, о чем выводится соответствующее сообщение. Также
имеется возможность сохранять и загружать начатые игры (файлы сохранений имеют
свой значок и расширение *.xvo).
Начало новой игры - команда меню File->New (или значок , сохранение игры - File -> SaveAs… или File
-> Save (или значок, открытие сохраненной игры - File -> Open…(или значок ), распечатка начатой игры File -> Print … (или значок ).

2. Блок-схема
алгоритма

3. Описание
работы программного продукта

В данном пункте следует
привести описание работы программы с приведением необходимого кода, рассказать
об основных и вспомогательных функциях, о назначении массивов и методов,
структуре алгоритма программы.

Структура программы
строится на пяти классах, каждый из которых создан на основе своего базового
класса, взятого из MFC, это классы:

·
CXvsOv1App относится к работе самой
программы;

·
CXvsOv1Doc занимается обработкой рабочих
документов;

·
CXvsOv1View осуществляет отображение
документов в рабочем окне;

·
CMainFrame
обслуживает работу базового окна программы;

·
CAboutDlg
обеспечивает работу диалогового окна About (О программе).

В программе данные
хранятся в объекте document, а за их отображение отвечает объект view.
Фактическим же местом вывода отображаемых данных является окно просмотра. Для
SDI-программ данное окно перекрывает видимую клиентскую часть базового окна,
которое появляется после компановки подготовленной в AppWizard программы. То,
что выглядит как клиентская часть окна - светлая область, обрамленная сверху
панелью инструментов, а снизу строкой состояния, - фактически является окном
просмотра.

Используемые в программе
данные хранится в виде массива полей длиной 1 байт, каждый из которых описывает
текущее состояние отдельной клетки игрового поля; этот массив представляет
собой элемент данных (data member) класса document. В любой момент класс view
может запросить у класса document сведения по каждой клетке и отобразить их на
экране. Кроме того, он добавляет в класс document сведения о крестиках и
ноликах, когда пользователь щелкает по пустой клетке.

Клетки, образующие
игровое поле, задаются матрицей CRect-элементов размерностью 5х5.

Блок инициализации
переменной m_rect выглядит так:

CXvsOv1View::CXvsOv1View()

{

for (int i=0;
i<5; i++) {

for (int j=0;
j<5; j++) {

int x = (i *
70) + 10;

int y = - (j *
70) - 10;

m_rect[i][j].SetRect
(x, y, x + 60, y - 60);

m_rect[i][j].NormalizeRect();

}

}}

Для отображения игры на
экране используется система координат с единицей измерения, равной 0,01 дюйм. Точка (0,0) - начало координат - находится в верхнем левом углу окна; ось X направлена
вправо, ось Y - вверх. Именно по этой причине Y-координаты клеток, назначаемые
конструктором, имеют отрицательные значения, а не положительные. Если бы были
указаны положительные значения Y, клетки оказались бы за пределами видимой
части окна.

Прорисовка игрового поля
осуществляется в методе OnDraw. Когда Windows-программа производит вывод
на экран, принтер или любое другое устройство вывода, она это делает с
использованием так называемого контекста устройства (device context - DC) -
некоторой структуры данных, содержащей важные сведения о характеристиках
конкретного выводного устройства и о параметрах, применяемых для вывода в
данной программе. Поскольку спецификация Graphics Device Interface (интерфейс
графических устройств - GDI) системы Windows позволяет получить
аппаратно-независимую модель вывода, одна и та же функция будет работать с
любым выводным устройством, для которого имеется соответствующий
Windows-драйвер.

Вызов функции
CDC::SetMapMode присваивает схеме соответствия для контекста устройства
значение MM_LOENGLISH, предписывающее, что единицей измерения служит 0,01 дюйм (имеется в виду логический дюйм). Размер логического дюйма определяется некоторым принятым
количеством пикселов, необходимым дл отображения реального дюйма на конкретном
выводном устройстве. Например, при выводе на принтер один логический дюйм
равняется одному физическому (реальному). При выводе на экран размер логического
дюйма, как правило, колеблется от 1 до 1,5 физических.

Вложенный цикл for сначала перерисовывает квадраты, а
затем, если от функций CXvsOv1Doc::GetSquare
получено ненулевое значение, обращается к функции DrawX или DrawO (о функциях
класса Doc и функциях DrawX или DrawO будет
сказано позднее). Итак, метод OnDraw
выглядит следующим образом (функция GetSquare, речь о которой пойдет ниже,
осуществляет здесь повторную прорисовку окна после сворачивания):

void
CXvsOv1View::OnDraw(CDC* pDC)

{

CXvsOv1Doc*
pDoc = GetDocument();

ASSERT_VALID(pDoc);

// Задать режим
отображения MM_LOENGLISH,

// в котором за единицу
измерения толщины принимается 0,01 дюйма:

pDC->SetMapMode
(MM_LOENGLISH);

// Прорисовать игровое
поле:

for (int i=0;
i<5; i++){

for (int j=0;
j<5; j++){

//цикл сначала
перерисовывает квадраты, а затем, если от функций

//CXvsOv1Doc::GetSquare
получено ненулевое значение, обращается к функции DrawX или DrawO

pDC->Rectangle
(m_rect [i][j]);

BYTE bVal =
pDoc->GetSquare (i,j);

if (bVal == 1) //
Проставить Х

DrawX (pDC,
&m_rect[i][j]);

else if (bVal
== 2) // Проставить О

Draw0 (pDC,
&m_rect[i][j]);

}

Далее следует рассказать
о блоке, отвечающем за рисование крестиков и ноликов после щелчков мыши на
клетках поля.

Kогда игрок щелкает левой клавишей и
указатель мыши находится в пределах клиентской области окна, оно получает
сообщение WM_LBUTTONDOWN. Для отслеживания подобных событий используется
принадлежащая классу view
функция OnLButtonDown. В начале модуля XvsOv1View
находится карта сообщений - особая таблица, в которой устанавливаются
соответствия между сообщениями и их обработчиками); с ее помощью будет
обеспечиваться вызов функции OnLButtonDown при приеме View-модулем сообщения
WM_LBUTTONDOWN. В составе функции OnLButtonDown также присутствует блок
преобразования координат поля в размерность MM_LOENGLISH:

CClientDC dc (this);

dc.SetMapMode (MM_LOENGLISH);

dc.DPtoLP (&point);

Итак, функция
OnLButtonDown при щелчке на клетке игрового поля обращается к функции GetSquare
класса document, чтобы выяснить, оставлен ли в ней значок Х или О. Если
GetSquare передает в качестве результата 0, значит клетка пуста, и
OnLButtonDown вызывает функцию IsItXsTurn, чтобы получить информацию о том,
какой значок нужно вставить - Х или О. Далее с помощью функций AddX или AddO
класса document в клетку заносится крестик или нолик. Затем выполняется функция
DrawX или DrawO класса view. В конце выполняется функция VinControl(). (Обо
всех этих функциях будет сказано ниже). Функция OnLButtonDown выглядит
следующим образом:

void
CXvsOv1View::OnLButtonDown(UINT nFlags, CPoint point)

{

// Получаем указатель на
класс document:

CXvsOv1Doc* pDoc =
GetDocument ();

//Берется контекст
устройства для клиентской области окна, в качестве схемы

// соответствия для
контекста задается MM_LOENGLISH

CClientDC dc (this);

dc.SetMapMode
(MM_LOENGLISH); //Конвертация CPoint-компонентов в MM_LOENGLISH

dc.DPtoLP (&point);

// Проверяем попадание
указателя мыши

// на клетку игрового
поля.

// Если да, рисуем Х или
О.

BOOL bQuit =
FALSE;

for (int i=0;
i<5 && !bQuit; i++) {

for (int j=0;
j<5 && !bQuit; j++) {

if
(m_rect[i][j].PtInRect (point)) {

//Если после
преобразования функция PtInRect передает ненулевое RETURN-значение,

//следовательно курсор
находится внутри клетки. В этом случае переменные i и j

//содержит индексы,
указывающие положение данной клетки.

//Если координаты,
переданные аргументом CPoint, лежат за пределами всех

//имеющихся клеток, то
вложенный цикл for заканчтвается

if
(pDoc->GetSquare (i, j) == 0) {

if (pDoc->IsItXsTurn
()) {

pDoc->AddX
(i, j);

DrawX
(&dc, &m_rect[i][j]);

} else {

pDoc->AddO
(i, j);

Draw0
(&dc, &m_rect[i][j]);

}

bQuit = TRUE;

}

CXvsOv1View::VinControl();

CView::OnLButtonDown(nFlags,
point);

}

Для прорисовки крестиков
и ноликов используется две функции класса view - DrawX и DrawO. В
процессе рисования они используют функции вывода класса CDC. Сначала DrawX
создает инструмент для рисования - красный карандаш (pen) для линий толщиной 10
условных единиц (для типа отображения MM_LOENGLISH одна условная единица
эквивалентна 0,1 логического дюйма):

CPen pen
(PS_SOLID, 10, RGB(255, 0, 0));

Затем с
помощью следующих предложений рисуются две пересекающиеся линии:

pDC->MoveTo (rect.left, rect.top);

pDC->LineTo (rect.right, rect.bottom);

pDC->MoveTo (rect.left, rect.bottom);

pDC->LineTo (rect.right, rect.top);

Аналогичным
образом функция DrawO создает свой инструмент для рисования - карандаш синего
цвета для линий толщиной 10 условных единиц:

CPen pen (PS_SOLID, 10, RGB(0, 0, 255));

и рисует O с
помощью MFC-функции CDC::Ellipse

pDC->Ellipse (rect);

В обоих
случаях до начала каких-либо операций рисования нужный карандаш выбирается в
контекст устройства с помощью функции CDC::SelectObject и возвращается обратно
по завершении работ с ним:

CPen* pOldPen = pDC->SelectObject (&pen);

pDC->SelectObject (pOldPen);

Чтобы
внутренняя область значка О не закрашивалась, в view-функции DrawO перед
обращением к CDC::Ellipse выбирается в контекст NULL-кисть - не заполняющая
область рисования:

pDC->SelectStockObject (NULL_BRUSH);

Функции DrawX и DrawO выглядят следующим образом:

void CXvsOv1View::DrawX(CDC *pDC, CRect *pRect)

{// Скопировать параметры переданного прямоугольника и

// уменьшить его размеры.

CRect rect;

rect.CopyRect (pRect);

rect.DeflateRect (10, 10);

// Создать красный карандаш и нарисовать им Х.

CPen pen (PS_SOLID, 10, RGB (255, 0, 0));

//нужный карандаш выбирается в контекст устройства с помощью функции CDC::SelectObject

CPen* pOldPen = pDC->SelectObject (&pen);

pDC->MoveTo (rect.left, rect.top); //

pDC->LineTo (rect.right, rect.bottom); //

pDC->MoveTo (rect.left, rect.bottom); //рисуются две пересекающиеся линии

pDC->LineTo (rect.right, rect.top); //

//карандаш возвращается обратно по завершении работ с ним

pDC->SelectObject (pOldPen);

}

void CXvsOv1View::Draw0(CDC *pDC, CRect *pRect)

{// Скопировать параметры переданного прямоугольника и

// уменьшить его размеры.

CRect rect;

rect.CopyRect (pRect);

rect.DeflateRect (10, 10);

// Создать синий карандаш и нарисовать им 0.

CPen pen (PS_SOLID, 10, RGB (0, 0, 255));

CPen* pOldPen = pDC->SelectObject (&pen);

pDC->SelectStockObject (NULL_BRUSH);

pDC->Ellipse (rect);//рисуется эллипс

//карандаш возвращается обратно по завершении работ с ним

pDC->SelectObject (pOldPen);

}

Функция VinControl()осуществляет проверку, выстроены ли в ряд 4 крестика или нолика и выводит соответствующие сообщения при выполнении этих условий. Функция содержит 56 циклов, при выполнении каждого из которого выводится соответствующее сообщение: "Крестики выстроили ряд!" или "Нолики выстроили ряд!". Функция VinControl()выглядит следующим образом:

void CXvsOv1View::VinControl()

{ CXvsOv1Doc* pDoc = GetDocument (); // Получаем указатель на класс document:

//Проверка победы крестиков по горизонталям

if ((pDoc->m_grid[0][0] == 1) && (pDoc->m_grid[1][0] == 1) && (pDoc->m_grid[2][0] == 1) && (pDoc->m_grid[3][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][0] == 1) && (pDoc->m_grid[2][0] == 1) && (pDoc->m_grid[3][0] == 1) && (pDoc->m_grid[4][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][1] == 1) && (pDoc->m_grid[1][1] == 1) && (pDoc->m_grid[2][1] == 1) && (pDoc->m_grid[3][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][1] == 1) && (pDoc->m_grid[2][1] == 1) && (pDoc->m_grid[3][1] == 1) && (pDoc->m_grid[4][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][2] == 1) && (pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][2] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][2] == 1) && (pDoc->m_grid[4][2] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][3] == 1) && (pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[3][3] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[3][3] == 1) && (pDoc->m_grid[4][3] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][4] == 1) && (pDoc->m_grid[1][4] == 1) && (pDoc->m_grid[2][4] == 1) && (pDoc->m_grid[3][4] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][4] == 1) && (pDoc->m_grid[2][4] == 1) && (pDoc->m_grid[3][4] == 1) && (pDoc->m_grid[4][4] == 1))

AfxMessageBox("Крестики выстроили ряд!");

//Проверка победы крестиков по вертикалям

if ((pDoc->m_grid[0][4] == 1) && (pDoc->m_grid[0][3] == 1) && (pDoc->m_grid[0][2] == 1) && (pDoc->m_grid[0][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][3] == 1) && (pDoc->m_grid[0][2] == 1) && (pDoc->m_grid[0][1] == 1) && (pDoc->m_grid[0][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][4] == 1) && (pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[1][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[1][1] == 1) && (pDoc->m_grid[1][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[2][4] == 1) && (pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[2][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[2][1] == 1) && (pDoc->m_grid[2][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

((pDoc->m_grid[3][4] == 1) && (pDoc->m_grid[3][3] == 1) && (pDoc->m_grid[3][2] == 1) && (pDoc->m_grid[3][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[3][3] == 1) && (pDoc->m_grid[3][2] == 1) && (pDoc->m_grid[3][1] == 1) && (pDoc->m_grid[3][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[4][4] == 1) && (pDoc->m_grid[4][3] == 1) && (pDoc->m_grid[4][2] == 1) && (pDoc->m_grid[4][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[4][3] == 1) && (pDoc->m_grid[4][2] == 1) && (pDoc->m_grid[4][1] == 1) && (pDoc->m_grid[4][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

//Проверка победы крестиков по диагоналям снизу слева - вверх вправо

if ((pDoc->m_grid[0][3] == 1) && (pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[2][1] == 1) && (pDoc->m_grid[3][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][4] == 1) && (pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][3] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][1] == 1) && (pDoc->m_grid[4][0] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][4] == 1) && (pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[3][2] == 1) && (pDoc->m_grid[4][1] == 1))

AfxMessageBox("Крестики выстроили ряд!");

//Проверка победы крестиков по диагоналям снизу справа - вверх влево

if ((pDoc->m_grid[1][0] == 1) && (pDoc->m_grid[2][1] == 1) && (pDoc->m_grid[3][2] == 1) && (pDoc->m_grid[4][3] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][0] == 1) && (pDoc->m_grid[1][1] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][3] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[1][1] == 1) && (pDoc->m_grid[2][2] == 1) && (pDoc->m_grid[3][3] == 1) && (pDoc->m_grid[4][4] == 1))

AfxMessageBox("Крестики выстроили ряд!");

if ((pDoc->m_grid[0][1] == 1) && (pDoc->m_grid[1][2] == 1) && (pDoc->m_grid[2][3] == 1) && (pDoc->m_grid[3][4] == 1))

AfxMessageBox("Крестики выстроили ряд!");

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

//Проверка победы ноликов по горизонталям

if ((pDoc->m_grid[0][0] == 2) && (pDoc->m_grid[1][0] == 2) && (pDoc->m_grid[2][0] == 2) && (pDoc->m_grid[3][0] == 2))