Сапер - Программирование, компьютеры и кибернетика курсовая работа

Предмет исследования – современные методы разработки программ таких, как объектно-ориентированное программирование и визуальное проектирование, а также структурное и модульное программирование. C++ - универсальный язык программирования. Ключевые понятия.


посмотреть текст работы


скачать работу можно здесь


полная информация о работе


весь список подобных работ


Нужна помощь с учёбой? Наши эксперты готовы помочь!
Нажимая на кнопку, вы соглашаетесь с
политикой обработки персональных данных

Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ УКРАИНЫ
ХАРЬКОВСКИЙ НАЦИОНАЛЬНЫЙ УНИВЕРСИТЕТ
"Объектно-ориентированное программирование"
Пояснительная записка к курсовой работе содержит: 46 стр., 5 рисунков
Предмет исследования - современные методы разработки программ таких, как объектно-ориентированное программирование и визуальное проектирование, а также структурное и модульное программирование.
Цель курсовой работы - систематизация, углубление и активное применение знаний по системному программированию, закрепление знаний, полученных в лекционном курсе, а также на практических и лабораторных занятиях.
Метод исследования - изучение литературы, составление и отладка программ на компьютере.
Данная программа используется для интересного проведения времени за игрой, которая требует развитого логического мышления. Разработан проект "Сапер" соответствующий условию задания и имеющий удобный интерфейс.
Программа разработана в среде Visual studio 2005.
КЛЮЧЕВЫЕ СЛОВА: VISUAL, ФУНКЦИЯ, ПРОЕКТ, ПРОГРАММА, САПЕР, БОМБА, ЯЧЕЙКА
#define OPEN_NULL_VALUES 0x00000100
class CMyCell // базовый класс для ячейки
CMyCell(int x = 0, int y = 0, int state = CLOSED); // координаты ячейки, начальное значение - закрытая ячейка
// устанавливаем значение координат ячейки
// Попадает ли точка, указанная в параметре, в область этой ячейки
bool HitToPoint(const CPoint & point);
// Выполняет действия при щелчке на эту ячейку
// Необходимо для инициализации поля
// Класс - указатель(умный указатель) на класс CMyCell
void SetPointer(CMyCell * pMyCell);
// Реализация класса CMyCell, т.е. класса ячейка
CMyCell:: CMyCell(int x, int y, int state)
: cellX(x), cellY(y), cellState(state) // доступ к переменным
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCell:: CMyCell(const CMyCell & copy)
: cellX(copy. GetX()), cellY(copy. GetY()), cellState(copy. GetState()) // копирующий уонструктор
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
return cellX; // возвращает значение x
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
return cellY; // возвращает значение у
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
return cellState; // возвращает значение позиции
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCell:: SetX(int x) // проверка на то, чтоб координата х была больше нуля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCell:: SetY(int y) // проверка на то, чтоб координата у была больше нуля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCell:: SetState(int state) // проверка на то, чтоб значение позиции было больше нуля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
bool CMyCell:: HitToPoint(const CPoint & point) // создание ячейки
{ if ((point. x > 10 + GetY() * (SIZE + 2)) && (point. x < 10 + GetY() * (SIZE + 2) + SIZE) &&
(point. y > 10 + GetX() * (SIZE + 2)) && (point. y < 10 + GetX() * (SIZE + 2) + SIZE))
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCell:: DrawClosedCell(CDC * dc) // прорисовка закрытой ячейки
CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
CPen * oldPen = dc->SelectObject(&pen);
CBrush * oldBrush = dc->SelectObject(&brush);
dc->Rectangle(10 + GetY() * (SIZE + 2), 10 + GetX() * (SIZE + 2),
10 + GetY() * (SIZE + 2) + SIZE, 10 + GetX() * (SIZE + 2) + SIZE);
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCell:: DrawBlockedCell(CDC * dc) // прорисовка заблокированной ячейки
CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
// CPen penBlock(PS_SOLID, 4, RGB(0, 0, 0));
CPen * oldPen = dc->SelectObject(&pen);
CBrush * oldBrush = dc->SelectObject(&brush);
dc->Rectangle(10 + GetY() * (SIZE + 2), 10 + GetX() * (SIZE + 2),
10 + GetY() * (SIZE + 2) + SIZE, 10 + GetX() * (SIZE + 2) + SIZE);
// CPen * oldBlockPen = dc->SelectObject(&penBlock);
dc->TextOutA(10 + GetY() * (SIZE + 2) + 6, 10 + GetX() * (SIZE + 2) + 3, "B", 1); // обозначение флажка
dc->SelectObject(oldBrush); // указатель на обьект ячейки
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
// Реализация класса CPMyCell // // // // // // // // // // // // // // // // // /
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
: pCell (NULL) // конструктор по умолчанию
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CPMyCell:: CPMyCell(CMyCell * pMyCell)
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CPMyCell:: SetPointer(CMyCell * pMyCell)
pCell = pMyCell; // конструктор копирования, установка указателя
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCell * CPMyCell:: GetPointer() const
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CPMyCell:: Destroy() // удаление ячейки
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCell * CPMyCell:: operator - >()
class CMyCellBomb: public CMyCell // ячейка с бомбой
CMyCellBomb(int x = 0, int y = 0, int state = CLOSED); // задаем координаты ячейки с бомбо. изначальный вид - ячейка закрыта
CMyCellBomb(const CMyCellBomb & copy); // конструктор копирования
// Выполняет действия при щелчке на эту ячейку
// Возвращает значение, по которому определяется, есть ли тут бомба.
// Необходимо для инициализации поля
// Реализация класса CMyCellBomb, т.е. ячейки с бомбой
CMyCellBomb:: CMyCellBomb(int x, int y, int state)
: CMyCell(x, y, state) // устанавливаем координаты ячейки, конструктор по умолчанию
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCellBomb:: CMyCellBomb(const CMyCellBomb & copy)
: CMyCell(copy) // конструктор копирования
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCellBomb:: ~CMyCellBomb() // деструктор
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCellBomb:: Draw(CDC * dc) // рисуем бомбы
if (GetState() == CLOSED) // если закрыто, то рисуем закрытую ячейку
else if (GetState() == BLOCK) // если стоит флажок, то рисуем флажок
CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
CPen * oldPen = dc->SelectObject(&pen);
CBrush * oldBrush = dc->SelectObject(&brush);
dc->Rectangle(10 + GetY() * (SIZE + 2), 10 + GetX() * (SIZE + 2),
10 + GetY() * (SIZE + 2) + SIZE, 10 + GetX() * (SIZE + 2) + SIZE);
CBrush * oldBrushCircle = dc->SelectObject(&brushCircle);
dc->Ellipse(10 + GetY() * (SIZE + 2) + 4, 10 + GetX() * (SIZE + 2) + 4,
10 + GetY() * (SIZE + 2) + SIZE - 4, 10 + GetX() * (SIZE + 2) + SIZE - 4);
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int CMyCellBomb:: Click(CDC * dc) // проверка на щелчок
if (GetState() == BLOCK) // если стоит флажок, то ячейка не откроется при нажатии
SetState(OPENED); // открытие ячейки
return REDRAW | GAMEOVER; // т. к. в ячейке находится бомба, а вы ее открываете, то следовательно вы проиграли
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
bool CMyCellBomb:: isBomb() const // есть ли это бомба
class CMyCellWob: public CMyCell // ячейка без бомбы
CMyCellWob(int x = 0, int y = 0, int state = CLOSED, int val = 0); // задаем координаты ячейки и значение. начальное положение - закрытая ячейка
CMyCellWob(const CMyCellWob & copy); // копирующий конструктор
int GetValue() const; // передаем значения
// Выполняет действия при щелчке на эту ячейку
// Возвращает значение, по которому определяется, есть ли тут бомба.
// Необходимо для инициализации поля
// Реализация класса CMyCellBomb, т.е. ячейки с бомбой
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCellBomb:: CMyCellBomb(int x, int y, int state)
: CMyCell(x, y, state) // устанавливаем координаты ячейки, конструктор по умолчанию
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCellBomb:: CMyCellBomb(const CMyCellBomb & copy)
: CMyCell(copy) // конструктор копирования
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCellBomb:: ~CMyCellBomb() // деструктор
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void CMyCellBomb:: Draw(CDC * dc) // рисуем бомбы
if (GetState() == CLOSED) // если закрыто, то рисуем закрытую ячейку
else if (GetState() == BLOCK) // если стоит флажок, то рисуем флажок
CPen pen(PS_SOLID, 1, RGB(0, 0, 0));
CPen * oldPen = dc->SelectObject(&pen);
CBrush * oldBrush = dc->SelectObject(&brush);
dc->Rectangle(10 + GetY() * (SIZE + 2), 10 + GetX() * (SIZE + 2),
10 + GetY() * (SIZE + 2) + SIZE, 10 + GetX() * (SIZE + 2) + SIZE);
CBrush * oldBrushCircle = dc->SelectObject(&brushCircle);
dc->Ellipse(10 + GetY() * (SIZE + 2) + 4, 10 + GetX() * (SIZE + 2) + 4,
10 + GetY() * (SIZE + 2) + SIZE - 4, 10 + GetX() * (SIZE + 2) + SIZE - 4);
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int CMyCellBomb:: Click(CDC * dc) // проверка на щелчок
if (GetState() == BLOCK) // если стоит флажок, то ячейка не откроется при нажатии
SetState(OPENED); // открытие ячейки
return REDRAW | GAMEOVER; // т. к. в ячейке находится бомба, а вы ее открываете, то следовательно вы проиграли
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
bool CMyCellBomb:: isBomb() const // есть ли это бомба
class MyField // класс поле, класс-контейнер
int GetCols() const; // значение колонок
int GetRows() const; // значение строк
int GetBombsCount() const; // количество бомб
int GetFindBombsCount() const; // количество найденных бомб вокруг ячейки
CMyCell * GetCellByIndex(int i, int j);
CPMyCell * GetPCellByIndex(int i, int j);
void SetCellByIndex(int i, int j, CMyCell * cell);
void Init(int cs, int rs, int kb); // инициализация
void ReInit(int cs, int rs, int kb); // перерисовка поля
int Click(CDC * dc, const CPoint & point);
void Block(CDC * dc, const CPoint & point);
bool TestOnWin(); // тест на выигрыш
int CalcValueForCell(int i, int j); // подсчитываем цифры для ячейки
bool CheckCell(int i, int j); // проверяем. есть ли это ячейка
void OpenNullValues(int i, int j); // открываем пустую ячейку
void IncFindBombs(); // увеличиваем на еденицу количество бомб
void DecFindBombs(); // уменьшаем на еденицу количество бомб
// Класс для работы с полем обьектов CMyCell
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
: cols(10), rows(10), kolBombs(10), field(NULL) // вводим значения
srand(time(0)); // задает новое значение для генерации случайных чисел
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: GetCols() const // доступ к колонкам
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: GetRows() const // доступ к строкам
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: GetBombsCount() const // доступ к количеству бомб
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: GetFindBombsCount() const // доступ к значению количества найденных бомб вокруг ячейки
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: SetCols(int c) // проверка на то, что колонки больше нуля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: SetRows(int r) // проверка на то, что строки больше нуля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: SetBombsCount(int kol) // ограничиваем количество бомб
int maxVal = GetCols() * GetRows() - GetCols() - GetRows(); // условие количества
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: SetFindBombsCount(int kol)
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CMyCell * MyField:: GetCellByIndex(int i, int j)
if (field == NULL) // если щелчок просто по полю, то ничего не происходит
if (i >= 0 && i < GetCols() && j >= 0 && j < GetRows()) // чтоб ячейка не выходила за рамки поля
return field [i] [j] ; // расширение-сужение поля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CPMyCell * MyField:: GetPCellByIndex(int i, int j) // массив указателей
if (i >= 0 && i < GetCols() && j >= 0 && j < GetRows())
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: SetCellByIndex(int i, int j, CMyCell * cell) // установка ячейки по индексу
if (field == NULL) // если поле пустое
if (i >= 0 && i < GetCols() && j >= 0 && j < GetRows())
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: Init(int cs, int rs, int kb) // задаем значения
if (field! = NULL) // поле не пустое
field = new CPMyCell* [GetCols()] ; // создание двумерного массива в виде строк и столбцов
for (int i = 0; i < GetCols(); i++)
field [i] = new CPMyCell [GetRows()] ;
// Конструктор это делает по умолчанию сам, но если вдруг разкоментировать
// for (int i = 0; i < GetCols() * GetRows(); i++)
// Генерируем, где расспалагаются бомбы
int tmp = GetBombsCount(); // временные переменные
if (field [tmp_cs] [tmp_rs]. GetPointer() == NULL) // если нет бомбы
tmp--; // уменьшаем количество бомб на еденицу
field [tmp_cs] [tmp_rs]. SetPointer(new CMyCellBomb(tmp_cs, tmp_rs, CLOSED));
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
if (field [i] [j]. GetPointer() == NULL) // Значит не занятая бомбой
field [i] [j]. SetPointer(new CMyCellWob(i, j, CLOSED, CalcValueForCell(i, j)));
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: ReInit(int cs, int rs, int kb) // перерисовка поля
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: DeInit() // очистка поля
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
if (field [i] [j]. GetPointer() ! = NULL)
for (int i = 0; i < GetCols(); i++) // удаление массива
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: Draw(CDC * dc) // рисуем поле
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: Click(CDC * dc, const CPoint & point) // проверка, попала ли мышь по ячейке
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
if (field [i] [j] ->HitToPoint(point))
int res = field [i] [j] ->Click(dc); // если попала по ячейке, то открываем ее
if (TestOnWin()) // тест на выигрыш
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: Block(CDC * dc, const CPoint & point) // возможность ставить флажки по всему полю
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
if (field [i] [j] ->HitToPoint(point))
if (field [i] [j] ->GetState() == OPENED)
if (field [i] [j] ->GetState() == CLOSED)
field [i] [j] ->SetState(BLOCK); // проверка на флажок
if (field [i] [j] ->GetState() == BLOCK) // правая кнопка убирает флажок
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
int MyField:: CalcValueForCell(int i, int j)
// Обходим все соседние ячейки в поисках бомб
if (GetCellByIndex(i, j - 1) ! = NULL && GetCellByIndex(i, j - 1) - >isBomb())
if (GetCellByIndex(i - 1, j - 1) ! = NULL && GetCellByIndex(i - 1, j - 1) - >isBomb())
if (GetCellByIndex(i - 1, j) ! = NULL && GetCellByIndex(i - 1, j) - >isBomb())
if (GetCellByIndex(i - 1, j + 1) ! = NULL && GetCellByIndex(i - 1, j + 1) - >isBomb())
if (GetCellByIndex(i, j + 1) ! = NULL && GetCellByIndex(i, j + 1) - >isBomb())
if (GetCellByIndex(i + 1, j + 1) ! = NULL && GetCellByIndex(i + 1, j + 1) - >isBomb())
if (GetCellByIndex(i + 1, j) ! = NULL && GetCellByIndex(i + 1, j) - >isBomb())
if (GetCellByIndex(i + 1, j - 1) ! = NULL && GetCellByIndex(i + 1, j - 1) - >isBomb())
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
bool MyField:: CheckCell(int i, int j)
if (i >= 0 && j >= 0 && i < GetCols() && j < GetRows())
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: OpenAll() // открытие ячеек
// передаем значение номера строки и столбца
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
void MyField:: OpenNullValues(int i, int j) // пустые ячейки, а вокруг цифры
if (GetCellByIndex(i, j) - >isBomb())
if (countItter! = 0 && (GetCellByIndex(i, j) - >GetState() == OPENED ||
GetCellByIndex(i, j) - >GetState() == BLOCK)) // не может открыть ячейку, если она уже открыта либо стоит с флажком
GetCellByIndex(i, j) - >SetState(OPENED);
// Обходим все соседние ячейки чтобы их открыть
if (((CMyCellWob *) GetCellByIndex(i, j)) - >GetValue() == 0)
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
kolFindBombs++; // увеличиваем количество найденных бомб на еденицу
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
kolFindBombs--; // уменьшаем количество найденных бомб на еденицу
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
bool MyField:: TestOnWin() // тест на выигрыш
for (int i = 0; i < GetCols(); i++)
for (int j = 0; j < GetRows(); j++)
(field [i] [j] ->GetState() == CLOSED ||
field [i] [j] ->GetState() == BLOCK))
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // /
CsaperDlg(CWnd* pParent = NULL); // standard constructor
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
private: // внутренние переменные и функции класса
afx_msg void OnLButtonDown(UINT nFlags, CPoint point); // функция для щелчка левой кнопкой мыши
afx_msg void OnRButtonDown(UINT nFlags, CPoint point); // функция для щелчка правой кнопкой мыши
afx_msg void OnBnClickedButtonExit(); // функция выхода из игры
afx_msg void OnBnClickedButtonStart(); // функция для начала игры
// saperDlg. cpp: implementation file
CsaperDlg:: CsaperDlg(CWnd* pParent /*=NULL*/)
: CDialog(CsaperDlg:: IDD, pParent), isInitAll(false), begin (false), isFirstClick(true)
m_hIcon = AfxGetApp() - >LoadIcon(IDR_MAINFRAME);
nameOfPowered = "Разработчик: Гаврюшенко Мария Александровна\r\nГруппа: КН-06-4";
void CsaperDlg:: DoDataExchange(CDataExchange* pDX)
DDX_Text(pDX, IDC_EDIT_BOMBS_COUNT, bombsCount);
DDV_MinMaxInt(pDX, bombsCount, 1, 4096);
DDX_Text(pDX, IDC_EDIT_HEIGHT, height);
DDV_MinMaxInt(pDX, height, 10, 40);
DDX_Text(pDX, IDC_EDIT_WIDTH, width);
BEGIN_MESSAGE_MAP(CsaperDlg, CDialog)
ON_BN_CLICKED(IDC_BUTTON_EXIT, &CsaperDlg:: OnBnClickedButtonExit)
ON_BN_CLICKED(IDC_BUTTON_START, &CsaperDlg:: OnBnClickedButtonStart)
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// значения, которые находятся в окне
CRect rect; // задаем значения переменным
height = field. GetCols(); // высота
width = field. GetRows(); // ширина
bombsCount = field. GetBombsCount(); // счетчик бомб
SetPosition(); // устанавливаем позицию
return TRUE; // return TRUE unless you set the focus to a control
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, reinterpret_cast(dc. GetSafeHdc()), 0);
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
int x = (rect. Width() - cxIcon + 1) / 2;
int y = (rect. Height() - cyIcon + 1) / 2;
brush. CreateSolidBrush(RGB(255, 255, 255));
CBrush * oldBrush = dc->SelectObject(&brush);
dc->Rectangle(8, 8, field. GetRows() * (SIZE + 2) + 10,
field. GetCols() * (SIZE + 2) + 10);
// The system calls this function to obtain the cursor to display while the user drags
HCURSOR CsaperDlg:: OnQueryDragIcon()
return static_cast(m_hIcon);
void CsaperDlg:: OnLButtonDown(UINT nFlags, CPoint point)
if (point. x < 10 || point. x > (field. GetRows() * (SIZE + 2) + 3) ||
point. y < 10 || point. y > (field. GetCols() * (SIZE + 2) + 3))
// если при первом щелчке вы проиграли, то поле перерисовуется
field. ReInit(field. GetCols(), field. GetRows(), field. GetBombsCount());
ShowFindBombs(); // показывает найденные бомбы
if (result & REDRAW) // перерисовуем поле
if (result & GAMEOVER) // если вы проиграли
MessageBox("Вы проиграли!!!: '(", "Конец игры", MB_OK);
if (result & WINNER) // если вы выиграли
MessageBox("Вы выграли!!!:)))", "Конец игры", MB_OK);
CDialog:: OnLButtonDown(nFlags, point);
void CsaperDlg:: OnRButtonDown(UINT nFlags, CPoint point)
if (point. x < 10 || point. x > (field. GetRows() * (SIZE + 2) + 3) ||
point. y < 10 || point. y > (field. GetCols() * (SIZE + 2) + 3))
CDialog:: OnRButtonDown(nFlags, point);
void CsaperDlg:: OnBnClickedButtonExit()
void CsaperDlg:: OnBnClickedButtonStart()
field. ReInit(height, width, bombsCount); // перерисовка
bombsCount = field. GetBombsCount();
MoveWindow(rect. left, rect. top, field. GetRows() * (SIZE + 2) + 230,
field. GetCols() * (SIZE + 2) + 80, TRUE);
GetDlgItem(IDC_STATIC_BOMBS_COUNT) - >SetWindowTextA("Количество бомб: ");
GetDlgItem(IDC_STATIC_BOMBS_COUNT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 30,
GetDlgItem(IDC_EDIT_BOMBS_COUNT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 160,
GetDlgItem(IDC_STATIC_HEIGHT) - >SetWindowTextA("Высота: ");
GetDlgItem(IDC_STATIC_HEIGHT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 30,
GetDlgItem(IDC_EDIT_HEIGHT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 160,
GetDlgItem(IDC_STATIC_WIDTH) - >SetWindowTextA("Ширина: ");
GetDlgItem(IDC_STATIC_WIDTH) - >MoveWindow(field. GetRows() * (SIZE + 2) + 30,
GetDlgItem(IDC_EDIT_WIDTH) - >MoveWindow(field. GetRows() * (SIZE + 2) + 160,
GetDlgItem(IDC_BUTTON_START) - >SetWindowTextA("Начать");
GetDlgItem(IDC_BUTTON_START) - >MoveWindow(field. GetRows() * (SIZE + 2) + 70,
GetDlgItem(IDC_BUTTON_EXIT) - >SetWindowTextA("Выход");
GetDlgItem(IDC_BUTTON_EXIT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 70,
GetDlgItem(IDC_STATIC_POWEREDBY) - >SetWindowTextA(nameOfPowered);
GetDlgItem(IDC_STATIC_POWEREDBY) - >MoveWindow(rect. Width() / 2 - 180,
rect. Height() - 65, 350, 50, FALSE);
void CsaperDlg:: ShowFindBombs() // показать найденные бомбы
pNum = itoa(field. GetBombsCount() - field. GetFindBombsCount(), num, 10); // перевод цифрового значения в строчный
GetDlgItem(IDC_STATIC_FIND_BOMBS_COUNT) - >SetFont(&fontFindBombs, TRUE);
GetDlgItem(IDC_STATIC_FIND_BOMBS_COUNT) - >SetWindowTextA(pNum);
GetDlgItem(IDC_STATIC_FIND_BOMBS_COUNT) - >MoveWindow(field. GetRows() * (SIZE + 2) + 70,
Понятие алгоритма и его характеристики как основного элемента программирования. Формы представления алгоритмов, основные алгоритмические структуры. Структурное и событийно-ориентированное программирование. Объектно-ориентированное программирование. реферат [86,0 K], добавлен 17.07.2008
Почему C++. Возникновение и эволюция языка C++. Сравнение языков С++ и С. Эффективность и структура. Процедурное программирование. Модульное программирование. Абстракция данных. Объектно-ориентированное программирование. Улучшенный С. реферат [26,4 K], добавлен 03.06.2004
Особенности разработки программ для ЭВМ. Этапы планирования программы. Понятие и особенности алгоритмов. Средства, используемые для создания программ. Виды и классификация языков программирования. Структурное и объектно-ориентированное программирование. реферат [59,7 K], добавлен 19.08.2010
Использование скриптового языка программирования для разработки web-приложений (сценариев). Изучение основ объектно-ориентированного программирования в языке PHP. Ознакомление со специальными методами для работы с классами. Назначение интерфейсов. контрольная работа [25,1 K], добавлен 14.03.2015
Приемы и правила объектно-ориентированного программирования с использованием языка С++. Общие принципы разработки объектно-ориентированных программ. Основные конструкции языка С++. Разработка различных программ для Windows с использованием WIN32 API. учебное пособие [1,6 M], добавлен 28.12.2013
Характеристика модульного программирования: процедуры и функции, модули и их структура, открытые массивы и строки, нетипизированные параметры. Способы передачи параметров в подпрограммы в Borland Pascal. Объектно-ориентированное программирование. контрольная работа [28,9 K], добавлен 28.04.2009
Характеристики и свойства языков программирования. Исследование эволюции объектно-ориентированных языков программирования. Построение эволюционной карты механизмов ООП. Разработка концептуальной модели функционирования пользовательского интерфейса. курсовая работа [2,6 M], добавлен 17.11.2014
Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д. PPT, PPTX и PDF-файлы представлены только в архивах. Рекомендуем скачать работу .

© 2000 — 2021



Сапер курсовая работа. Программирование, компьютеры и кибернетика.
Курсовая работа по теме Управление ценовой политикой предприятия ОАО 'Бобруйский мясокомбинат'.
Желтков Великий Или Маленький Человек Сочинение
Эссе На Тему Мой Любимый Казахстанский Певец
Творческая Работа На Тему Доказательства Того, Что В Гобсеке Живут Два Существа: Скряга И Философ
Реферат по теме Модули, файлы и записи
Реферат: Интуиция как вид творческого мышления
Дипломная работа по теме Транспортный налог, понятие, функции.
Курсовая работа: Изготовление ПЭТФ-бутылок
СРОКИ В НАЛОГОВОМ ПРАВЕ
Курсовая работа по теме Показатели эффективности использования основных фондов предприятия
Итоговое Сочинение 2022 На Тему Время Перемен
Написать Практическую Часть Курсовой Работы
Реферат: Ответственность за умышленное убийство при отягчающих обстоятельствах. Скачать бесплатно и без регистрации
Реферат по теме Структура, категории и функции социологии
Реферат: Эволюция предприятий гостеприимства
Контрольная работа по теме Юридическое лицо как правовая категория
Математика 5 Годовая Контрольная Работа
Связи И Реакции Связей Реферат
Реферат по теме Природа, сущность и назначение человека
Практическая Работа Базы Данных 11 Класс
Программное обеспечение Загорской ГАЭС - Программирование, компьютеры и кибернетика отчет по практике
Russia - Иностранные языки и языкознание контрольная работа
Анализ организационной структуры управления предприятием и разработка предложений по ее совершенствованию - Менеджмент и трудовые отношения дипломная работа