Разработка программы на основе принципов объектно-ориентированного программирования

Размещено на http://www.allbest.ru/

Пермский национальный исследовательский политехнический университет

Кафедра «Автоматика и телемеханика»

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

По дисциплине «Программирование и основы алгоритмизации»

«Разработка программы на основе принципов объектно-ориентированного программирования»

Пермь 2013



Введение

Цель курсовой работы: практическое применение знаний, умений и навыков, полученных в ходе изучения дисциплины, в частности, знаний базовых принципов объектно-ориентированного программирования для разработки программного обеспечения.

Реализовать прототип игры, обладающей следующими характеристиками. Имеется множество графических объектов: точки, прямоугольники, окружности. Графические объекты имеют случайные размеры и перемещаются по прямым линиям со случайными скоростями, при этом направление и скорость перемещения каждого объекта время от времени меняется случайным образом. Добавление нового графического объекта выполняется по нажатию клавиши Insert. Удаление последнего добавленного графического объекта выполняется по нажатию клавиши Delete. Кроме того, при запуске программы в центре экрана появляется управляемый объект (TCursor), который может перемещаться по экрану по нажатию клавиш со стрелками. Любой объект при выходе за пределы экрана появляется с противоположной стороны. Управляемый объект может выполнять «выстрел» по нажатию клавиши Enter. «Выстрел» приводит к появлению «луча», который начинается непосредственно рядом с управляемым объектом и заканчивается на границе экрана. Если «луч» пересекает графический объект, то графический объект удаляется, что сопровождается цветовым выделением. Новый «выстрел» может быть выполнен только через определенный промежуток времени (примерно 2-3 секунды), что отмечается соответствующим цветовым выделением управляемого объекта. Клавишами Delete и Page Down или клавишами F1 и F2 изменяется направление возможного «выстрела», то есть направление «луча». Выход из программы осуществляется по нажатию клавиши Esc.

программа игра объектный графический



1. Разработка программы

Создание объектов

Сначала необходимо определить основную структуру «Точка», от которой потом могут быть порождены более сложные структуры, реализующие более сложные графические объекты. Для этого добавляется описание нового типа TPoint. Объект структуры «Точка» содержит поля: координаты и цвет объекта. Но кроме этого объект может содержать в себе методы (функции). Частным случаем этих методов можно считать конструктор и деструктор объекта. Конструктор вызывается при создании объекта, а деструктор вызывается при удалении объекта. Остальные методы нужны для того, что определить поведение объекта. В частности для объекта «Точка» необходимы методы, связанные с его отображением (Draw, Show, Hide). Описание структуры TPoint формируется следующим образом.

struct TPoint {

int x, y, color;

TPoint(int ix, int iy, int icolor) {

x = ix; y = iy; color = icolor;

}

virtual ~TPoint() {

Hide();

}

virtual void Draw(int icolor) {

GrFilledCircle(x, y, 1, icolor);

}

void Show() {

Draw(color);

}

void Hide() {

Draw(bg);

}

};

После деструктора указана функция Draw, которая обеспечивает рисование окружности радиусом 1 заданным цветом icolor. Затем объявляются две функции: Show и Hide. Функция Show отображает объект с текущими параметрами. Функция Hide скрывает изображение объекта (рисование фоновым цветом). В конструкторе TPoint задаются изначальные координаты и цвет объекта согласно значениям аргументов конструктора. Деструктор ~TPoint обеспечивает скрытие изображения соответствующего графического объекта с помощью вызова его метода Hide. Принцип наследования обеспечивает удобный механизм дальнейшего развития программы, а именно реализации перемещения не только точек, но и других графических объектов, в частности, прямоугольников и окружностей. Чем перемещаемый прямоугольник и окружность отличаются от перемещаемой точки? Прямоугольник имеет ширину и высоту, а окружность имеет радиус, и отображаются они по-другому. Но в смысле механизма отображения и скрытия прямоугольник, окружность и точка аналогичны. Поэтому некоторые компоненты объект «Прямоугольник» и объект «Окружность» могут унаследовать от объекта «Точка». Для порождения объектов «Прямоугольник» и «Окружность» от объекта «Точка» для начала необходимо после описания класса TPoint добавить следующий фрагмент, реализующий описание структур «Прямоугольник» (TBox) и «Окружность»(TCircle).

struct TBox:public TPoint {

};

struct TCircle:public TPoint {

};

Это фрагмент формирует структуры TBox и TCircle, порожденные от класса TPoint. При этом получается, что эти объекты не отличаются от объекта TPoint, так как они наследуют все компоненты объекта TPoint, хотя эти компоненты и не отображаются явным образом. Но ведь объекты «Прямоугольник» и «Окружность» должны отличаться от объекта «Точка». Поэтому остается добавить только то, что специфично для прямоугольника и окружности, а именно ширину и высоту прямоугольника (переменные w и h), радиус окружности (переменная r), новые виртуальные методы Draw (они должны отображаться иначе, чем точка), новый конструктор TBox (так как необходимо задавать ширину и высоту при создании объекта) и новый конструктор TCircle(так как необходимо задавать радиус окружности), новые. Таким образом, описание структур «Прямоугольник» и «Окружность» необходимо изменить следующим образом.

struct TBox:public TPoint {

int w, h;

TBox(int ix, int iy, int icolor, int iw, int ih):TPoint(ix,iy,icolor) {

w = iw; h = ih;

}

virtual ~TBox() {

Hide();

}

void Draw(int icolor) {

GrBox(x - w / 2, y - h / 2, x + w / 2, y + h / 2, icolor);

}

};

struct TCircle:public TPoint {

int r;

TCircle(int ix, int iy, int icolor, int ir):TPoint(ix, iy, icolor) {

r = ir;

}

virtual ~TCircle() {

Hide();

}

void Draw(int icolor) {

GrCircle(x, y, r, icolor);

}

};

После заголовка конструктора через двоеточие указывается вызов конструктора объекта-предка.

Одновременно может использоваться несколько объектов, поэтому необходимо добавить константу, определяющую количество графических объектов на экране (например, 100 объектов), то есть непосредственно перед функцией main можно добавить строку.

int m = 1000;

Теперь можно обратиться к функции main. Для реализации графических объектов необходимо сформировать статический массив obj, который может содержать указатели на объект «Точка», то есть в начале функции main нужно добавить следующую строку.

TPoint * obj[m];

Затем необходимо создать само графическое окно. Для этого добавляем в программу следующий фрагмент.

char title[] = "GAME";

GrSetWindowTitle(title);

GrSetMode(GR_width_height_color_graphics, 900, 500, bg);

Функция GrSetWindowTitle устанавливает название окна. Функция GrSetMode устанавливает параметры графического окна: режим, ширину и высоту окна, фоновый цвет.

Добавление новых объектов реализуется при нажатии клавиши Insert, закрытие окна - при нажатии клавиши Escape.

Создание экземпляров объекта TPoint поисходит динамически с помощью оператора new. Каждый элемент массива obj - это указатель на некоторый объект класса TPoint. Предполагается, что каждый такой объект создается динамически, и для него выделяется динамическая память. Тогда obj[i] будет указателем на i-й объект. После оператора new указывается вызов конструктора объекта класса TPoint. При этом могут задаваться те или иные аргументы конструктора. Результат оператора new присваивается obj[i], тогда получается, что obj[i] будет указателем на i-й объект класса TPoint. Конструктор не отображает объект, поэтому для объекта obj[i] (указательна объект класса TPoint) вызывается его метод Show, то есть обеспечивается отображение этого объекта. Для реализации работы с клавиатурой необходимо добавить новую переменную key типа GrKeyType. Работа с клавиатурой выполняется следующим образом:

do {

if (GrKeyPressed()) {

key = GrKeyRead();

if(key == GrKey_Insert) {

switch (rand() % 3) {

case 0:

obj[n] = new TPoint(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255));

break;

case 1:

obj[n] = new TBox(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255), rand() % 20 + 10, rand() % 20 + 10);

break;

case 2:

obj[n] = new TCircle(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255), rand() % 10 + 5);

break;

}

obj[n++] -> Show();

}

} while(key != GrKey_Escape);

for(int i = 0; i < n; i++)

{

delete obj[i];

}

Программа будет находиться в этом цикле, пока не нажата клавиша Escape, которая рассматривается как клавиша для выхода из программы. При нажатии клавиши Insert происходит случайный выбор одного из трех объектов и добавление его в массив объектов. В переменной n хранится число созданных объектов. Важно, что после работы с объектами надо не забывать освобождать память, используемую для этих объектов. Освобождение памяти происходит с помощью оператора delete. При этом освобождается память, использовавшаяся для каждого экземпляра объекта, и совместно выполняются необходимые действия, связанные с удалением экземпляра объекта, на основе вызова деструктора. Другими словами, при вызове delete obj[i] сначала происходит вызов деструктора для i-го объекта, а затем выполняется освобождение памяти, ранее занятой для этого объекта. В данном случае вызов деструктора обеспечивает скрытие изображение объекта, поэтому объекты исчезают с экрана последовательно, хотя из-за быстрого формирования изображения это трудно заметить.

Результат работы такой программы выглядит следующим образом (цвета инвертированы).

Удаление последнего добавленного объекта

Для удаления последнего добавленного объекта цикл, рассмотренный в конце предыдущего пункта, необходимо изменить следующим образом (пусть удаление объекта происходит при нажатии клавиши Delete).

do {

if (GrKeyPressed()) {

key = GrKeyRead();

switch(key) {

case GrKey_Insert:

// . . .

break;

case GrKey_Delete:

if (n > 0) {

delete obj[n-- - 1];

}

break;

}

}

} while(key != GrKey_Escape);

При этом вместо двух комментария надо вставить уже имеющийся фрагмент программы, который обеспечивает создание случайного объекта.

Перемещение графических объектов по прямым траекториям

Для перемещения объекта по прямой траектории надо, чтобы для этого объекта сохранялся вектор скорости. Этот вектор скорости можно задавать двумя переменными vx и vy, которые соответственно определяют горизонтальную и вертикальную скорости. Каждый объект должен иметь свой вектор скорости, поэтому в описании объекта «Точка» надо добавить две переменные vx и vy типа int. При этом объекты «Прямоугольник» и «Окружность», а также другие объекты, порожденные от объекта «Точка», унаследуют эти переменные. Кроме того, надо выполнить начальную инициализацию этих переменных при создании экземпляра объекта. Для этого в конструкторе TPoint::TPoint надо присвоить этим переменным случайные значения, например, значения rand()%7-3. Тогда при появлении на экране графический объект будет иметь случайный вектор скорости. Для увеличения скорости перемещения можно использовать более широкий диапазон псевдослучайных чисел, например, rand()%11-5. Теперь следует выполнить перемещение каждого графического объекта согласно вектору скорости. Для этого необходимо в структуру TPoint добавить метод MoveXY, который будет отвечать за перемещение объектов в пределах графического окна. Для перемещения сначала убирается изображение объекта (Hide), затем координаты объекта (x и y) изменяются на заданные координаты (ix и iy), после этого объект отображается уже на новом месте (Show). Метод MoveXY может использоваться для перемещения любого объекта, если для него определен метод Draw, так как методы Hide и Show являются универсальными и основаны на методе Draw. Далее в программу необходимо добавить следующий фрагмент.

void MoveXY(int ix, int iy) {

Hide();

if (ix > GrMaxX())

x = ix - GrMaxX() - 1;

else if (ix < 0)

x = GrMaxX() + ix + 1;

else if (iy > GrMaxY())

y = iy - GrMaxY() - 1;

else if (iy < 0)

y = GrMaxY() + iy + 1;

else {

x = ix; y = iy;

}

Show();

}

Для того, чтобы объекты оставались в пределах графического окна, выполняется так называемое «закольцовывание» экрана, то есть если объект выходит за границу экрана, то появляется на противоположной границе.

Чтобы объекты начали перемещаться по прямым траекториям в программу перед добавлением нового объекта необходимо добавить следующий фрагмент.

GrSleep(20);

for(i = 0; i < n; i++) {

obj[i] -> MoveXY(obj[i]->x + obj[i]->vx, obj[i]->y + obj[i]->vy);

if(rand() % 50 == 1) {

obj[i] -> vx = rand() % 7 - 3;

obj[i] -> vy = rand() % 7 - 3;

}

}

При вычислении каждого аргумента к имеющейся координате объекта obj[i] прибавляется значение соответствующего компонента вектора скорости, то есть vx или vy этого объекта. Для обращения к vx и vy объекта obj[i] надо соотвественно ис-

пользовать obj[i]->vx и obj[i]->vy. Один из возможных вариантов реализации «закольцовывания» экрана состоит в том, что в функции MoveXY вместо безусловных присвоений переменных (x=ix; y=iy;) надо разместить аналогичные присвоения с учетом необходимых условий, используемых для проверки возможного выхода объекта за пределы экрана. Например, если оказывается, что ix больше GrMaxX(), то тогда x надо присвоить значение ix-GrMaxX()-1 (предполагается, что vx<=GrMaxX()) и т.д. При этом должны быть учтены все границы экрана. Чтобы векторы скоростей иногда случайным образом менялись надо сразу после вызова obj[i]->MoveXY выполнять случайное изменение вектора скорости объекта obj[i] аналогично тому, как это делается в конструкторе TPoint. Но важно, чтобы такое изменение происходило не каждый раз, а в некоторые случайные моменты времени. Для реализации этого достаточно, например, делать указанное изменение при условии, что значение rand()%50 равно 1.

Создание управляемого объекта

Согласно варианту задания при запуске программы в центре экрана появляется управляемый объект (TCursor), который может перемещаться по экрану по нажатию клавиш со стрелками. Любой объект при выходе за пределы экрана появляется с противоположной стороны. Управляемый объект может выполнять «выстрел» по нажатию клавиши. «Выстрел» приводит к появлению «луча», который начинается непосредственно рядом с управляемым объектом и заканчивается на границе экрана. Если «луч» пересекает графический объект, то графический объект удаляется, что сопровождается цветовым выделением. Новый «выстрел» может быть выполнен только через определенный промежуток времени (примерно 2-3 секунды), что отмечается соответствующим цветовым выделением управляемого объекта. Клавишами изменяется направление возможного «выстрела», то есть направление «луча».

Для начала добавим описание нового типа TCursor. Объекты структуры TCursor имеют следующие поля: координаты, цвет, длина "пушки", радиус, угол поворота "пушки". Описание данной структуры выглядит следующим образом.

struct TCursor {

int x, y, color, s, r;

double a;

TCursor(int ix, int iy, int icolor) {

s = 10; a = M_PI / 2; r = 5; x = ix; y = iy; color = icolor;

}

virtual ~TCursor();

void Draw(int icolor) {

GrCircle(x, y, r, icolor);

GrCircle(x, y, r / 2, icolor);

GrLine(x + r / 2 * cos(a), y - r / 2 * sin(a), x + s * cos(a), y - s * sin(a), icolor);

}

void Show();

void Hide();

void TurnGun(int prm) {

Hide();

a += prm * M_PI / 8;

Show();

}

void Laser(int color) {

GrLine(x + s * cos(a), y - s * sin(a), x + 1030 * cos(a), y - 1030 * sin(a), color);

}

void LaserShow() {

Laser(GrAllocColor(255, 255, 0));

}

void LaserHide() {

Laser(bg);

}

void MoveXY(int ix, int iy);

};

Методы Show, Hide, MoveXY и деструктор данного объекта аналогичны соответствующим методам структуры TPoint. В конструкторе TCursor задаются изначальные значения переменных объекта, согласно значениям аргументов конструктора (ix, iy, icolor). Функция Draw рисует управляемый объект, состоящий из двух окружностей и линии, играющей роль «пушки». Функция TurnGun выполняет поворот «пушки». Происходит это так: функции передается определенный параметр(-1 или 1), затем угол наклона «пушки» меняется соответственно на или на . Показ и скрытие луча выполняется с помощью трех функций, аналогичных функциям Draw, Show и Hide. Функция Laser рисует линию цветом color, которая начинается на конце «пушки» управляемого объекта и заканчивается на границе экрана. Функции Show и Hide служат для показа и скрытия луча соответственно. Управляемый объект и луч выглядят следующим образом.

Управление объектом с помощью клавиш.

Согласно варианту задания нужно реализовать перемещение управляемого объекта, поворот «пушки» и выстрел(показ луча). Для создания соответствия между нажатой клавишей и действием управляемого объекта необходимо в программу(перед или после блока добавления-удаления объектов) добавить следующий фрагмент.

case GrKey_Right:

first_obj -> MoveXY(first_obj -> x + 5, first_obj -> y);

break;

case GrKey_Left:

first_obj -> MoveXY(first_obj -> x - 5, first_obj -> y);

break;

case GrKey_Up:

first_obj -> MoveXY(first_obj -> x, first_obj -> y - 5);

break;

case GrKey_Down:

first_obj -> MoveXY(first_obj -> x, first_obj -> y + 5);

break;

case GrKey_F1:

first_obj -> TurnGun(1);

break;

case GrKey_F2:

first_obj -> TurnGun(-1);

break;

case GrKey_Space:

// ...

break;

Перемещение управляемого объекта происходит с помощью клавиш со стрелками, поворот «пушки» происходит с помощью клавиш F1 и F2, выстрел происходит при нажатии клавиши пробела.

На место комментария нужно будет поместить фрагмент, отвечающий за показ луча и удаление объектов, в которые этот луч попадает. Этот фрагмент рассматривается в следующем пункте.

1. Удаление объектов при попадании в них луча.

Для проверки попадания луча в объект для начала необходимо в структуры объектов добавить методы, которые будут возвращать размеры данного объекта. Реализуется это следующим образом. Для объекта «Точка»:

virtual int SizeX() {

return 1;

}

virtual int SizeY() {

return 1;

}

Для объекта «Прямоугольник»:

int SizeX() {

return w / 2;

}

int SizeY() {

return h / 2;

}

Для объекта «Окружность»:

int SizeY() {

return r;

}

Функции возвращают x и y координаты соответствующего объекта. Следует также отметить, что эти функции в структуре-предке должны быть объявлены как виртуальные. Теперь необходимо добавить определенные переменные, необходимые для проверки и удаления объектов:

t - количество объектов, попавших под луч;

del - массив номеров объектов, попавших под луч;

x, y - используются для сканирования экрана по лучу;

start - задает возможную частоту появления луча;

После нажатия клавиши пробела необходимо выполнить цикл перебора всех объектов и всех точек луча с проверкой пересечения луча и объекта. Если оказывается, что координаты x, y луча находятся внутри очередного объекта, то этот объект должен быть сначала окрашен в красный цвет, а затем удален подобно тому, как удаляется объект при нажатии клавиши Delete или удаляется очередной объект при удалении всех объектов после нажатия клавиши Escape. Но после такого удаления указатель obj[i] перестает указывать на экземпляр объекта, и если i<N, то тогда при последующем переборе объектов будет выполняться обращение к несуществующему экземпляру объекта. Чтобы этого избежать, надо сразу после удаления очередного объекта для всех элементов массива obj, находящихся после удаленного элемента и указывающих на тот или иной экземпляр объекта, выполнить их смещение на 1 в сторону начала массива obj. После этого значение N следует уменьшить на 1, а значение I должно оставаться без изменения. Цикл проверки выглядит следующим оразом:

t = 0;

for (i = 0; i < n; i++) {

x = first_obj -> x + (first_obj -> s) * cos(first_obj -> a);

y = first_obj -> y - (first_obj -> s) * sin(first_obj -> a);

for (j = first_obj -> s; x < GrMaxX() && y < GrMaxY() && x > 0 && y > 0; j++) {

x = first_obj -> x + j * cos(first_obj -> a);

y = first_obj -> y - j * sin(first_obj -> a);

if ((x > obj[i] -> x - obj[i] -> SizeX()) && (x < obj[i] -> x + obj[i] -> SizeX()) && (y > obj[i] -> y - obj[i] -> SizeY()) && (y < obj[i] -> y + obj[i] -> SizeY())) {

del[t++] = i;

break;

}

}

}

Если оказывается, что координаты x, y луча находятся внутри очередного объекта, то номер этого объекта заносится в массив номеров объектов, подлежащих удалению. После того, как проверены все точки луча, происходит смена цвета объектов, номера которых хранятся в массиве del, удаление объектов и смещение указателей в массиве obj. Реализуется это следующим образом.

if (clock() - start > (clock_t) 1000) {

first_obj -> color = GrAllocColor(127, 127, 127);

first_obj -> LaserShow();

// ...

for (i = 0; i < t; i++){

obj[del[i]] -> color = GrAllocColor(255, 0, 0);

obj[del[i]] -> Show();

}

GrSleep(100);

if (t != 0) {

Beep(600, 100);

GrSleep(100);

}

for (i = 0; i < t; i++) {

delete obj[del[i] - i];

for (j = del[i] - i; j < n-i; j++){

obj[j] = obj[j + 1];

}

}

n -= t;

first_obj -> LaserHide();

}

На месте комментария должен стоять цикл проверки попаданий.

Если с момента предыдущего выстрела прошло больше секунды, то меняем цвет на серый и показываем луч. Если с момента предыдущего выстрела еще не прошла одна секунда, то проверка не выполняется. После проверки идет цикл смены цвета объектов а красный. Затем, если луч пересек хотя бы один объект, происходит звуковое оповещение с помощью функции Beep библиотеки windows.h. После всего этого происходит поочередное удаление объектов и смещение указателей в массиве obj, затем количество созданных объектов уменьшается на количество удаленных объектов. Выглядит это следующим образом.

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



2. Описание разработанной программы

Исходный текст программы

#include <grx20.h>

#include <grxkeys.h>

#include <time.h>

#include <math.h>

#include <windows.h>

// максимальное число объектов

int m = 1000;

// фоновый цвет

GrColor bg = GrAllocColor(0, 0, 0);

// описание структуры "Точка"

struct TPoint {

// переменные

// x, y - координаты

// color - цвет

// vx, vy - векторы скорости

int x, y, color, vx, vy;

// конструктор, задающий начальные значения переменных

TPoint(int ix, int iy, int icolor) {

X = ix;y = iy;vx=rand() % 7 - 3;vy=rand() % 7 - 3;color = icolor;

}

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

virtual ~TPoint() {

Hide();

}

// отрисовка цетом icolor

virtual void Draw(int icolor) {

GrFilledCircle(x, y, 1, icolor);

}

// показ

void Show() {

Draw(color);

}

// скрытие

void Hide() {

Draw(bg);

}

// перемещение

// выполняется закольцовывание экрана

// объект, вылетая за границу окна,

// появляется на противоположной границе

void MoveXY(int ix, int iy) {

Hide();

if (ix > GrMaxX()) x = ix - GrMaxX() - 1;

else if (ix < 0) x = GrMaxX() + ix + 1;

else if (iy > GrMaxY()) y = iy - GrMaxY() - 1;

else if (iy < 0) y = GrMaxY() + iy + 1;

else {

x = ix; y = iy;

}

Show();

}

// размер по x

virtual int SizeX() {

return 1;

}

// размер по y

virtual int SizeY() {

return 1;

}

};

// описание структуры "Прямоугольник"

struct TBox:public TPoint {

// w - ширина

// h - высота

int w, h;

TBox(int ix, int iy,int icolor, int iw,int ih):TPoint(ix, iy, icolor) {

w = iw; h = ih;

}

virtual ~TBox() {

Hide();

}

void Draw(int icolor) {

GrBox(x - w / 2, y - h / 2, x + w / 2, y + h / 2, icolor);

}

int SizeX() {

return w / 2;

}

int SizeY() {

return h / 2;

}

};

// описание структуры "Окружность"

struct TCircle:public TPoint {

// r - радиус

int r;

TCircle(int ix, int iy, int icolor, int ir):TPoint(ix, iy, icolor) {

r = ir;

}

virtual ~TCircle() {

Hide();

}

void Draw(int icolor) {

GrCircle(x, y, r, icolor);

}

int SizeX() {

return r;

}

int SizeY() {

return r;

}

};

// описание структуры управляемого объекта "Курсор"

struct TCursor {

// x, y - координаты

// color - цвет

// s - длина "пушки"

// r - радиус

// a - угол поворота "пушки"

int x, y, color, s, r;

double a;

TCursor(int ix, int iy, int icolor) {

s = 10; a = M_PI / 2; r = 5; x = ix; y = iy; color = icolor;

}

virtual ~TCursor() {

Hide();

}

void Draw(int icolor) {

GrCircle(x, y, r, icolor);

GrCircle(x, y, r / 2, icolor);

GrLine(x+r/2*cos(a),y-r/2*sin(a),x+s*cos(a),y-s*sin(a),icolor);

}

void Show() {

Draw(color);

}

void Hide() {

Draw(bg);

}

// поворот "пушки"

void TurnGun(int prm) {

Hide();

a += prm * M_PI / 8;

Show();

}

// отрисовка луча цветом color

void Laser(int color) {

GrLine(x+s*cos(a),y-s*sin(a),x+1030*cos(a),y-1030*sin(a),color);

}

// показ луча

void LaserShow() {

Laser(GrAllocColor(255, 255, 0));

}

// скрытие луча

void LaserHide() {

Laser(bg);

}

void MoveXY(int ix, int iy) {

Hide();

if (ix > GrMaxX())

x = ix - GrMaxX() - 1;

else if (ix < 0)

x = GrMaxX() + ix + 1;

else if (iy > GrMaxY())

y = iy - GrMaxY() - 1;

else if (iy < 0)

y = GrMaxY() + iy + 1;

else {

x = ix; y = iy;

}

Show();

}

};

int main() {

// массив указателей на объект "Точка"

TPoint * obj[m];

// инициализация генератора случайных чисел

srand(time(NULL));

// название графического окна

char title[] = "GAME";

// установка названия

GrSetWindowTitle(title);

// создание графического окна

GrSetMode(GR_width_height_color_graphics, 900, 500, bg);

// указатель на управляемый объект

TCursor * first_obj;

// создание экземпляра управляемого объекта

first_obj = new TCursor(GrMaxX()/2,GrMaxY()/2,GrAllocColor(0, 255, 0));

first_obj -> Show();

// переменные

// i, j - счетчики, испольуемые в различных циклах

// n - количество созданных объектов

// t - количество объектов, попавших под луч

// del - массив номеров объектов, попавших под луч

// x, y - используются для сканирования экрана по лучу

// start - задает возможную частоту появления луча

// key - переменная, в которую считывается нажатая клавиша

int i, j, n = 0, t, del[m];

float x, y;

clock_t start = clock() - (clock_t) 1000;

GrKeyType key;

// пока не нажата клавиша Escape

do {

// если с момента выстрела прошло больше секунды,

// то меняем цвет управляемого объекта на зеленый

if (clock() - start > (clock_t) 1000) {

first_obj -> color = GrAllocColor(0, 255, 0);

}

// задержка 20 мсек

//GrSleep(20);

for(i = 0; i < n; i++) {

// перемещение всех объектов

// согласно их векторам скорости

obj[i] -> MoveXY(obj[i]->x+obj[i]->vx,obj[i]->y+obj[i]-> vy);

// изменение векторов скорости в случайный момент времени

if(rand() % 50 == 1) {

obj[i] -> vx = rand() % 7 - 3;

obj[i] -> vy = rand() % 7 - 3;

}

}

first_obj -> Show();

// если нажата какая-либо клавиша

if (GrKeyPressed()) {

// считывание клавиши

key = GrKeyRead();

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

switch(key) {

// добавление объекта

case GrKey_Insert:

if (n < m) {

switch (rand() % 3) {

case 0:

obj[n] = new TPoint(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255));

break;

case 1:

obj[n] = new TBox(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255), rand() % 20 + 10, rand() % 20 + 10);

break;

case 2:

obj[n] = new TCircle(rand() % GrMaxX(), rand() % GrMaxY(), GrAllocColor(255, 255, 255), rand() % 10 + 5);

break;

}

obj[n++] -> Show();

}

break;

// удаление последнего добавленного объекта

case GrKey_Delete:

if (n > 0) {

delete obj[n-- - 1];

}

break;

// перемещение управляемого объекта вправо

case GrKey_Right: case GrKey_d:

first_obj -> MoveXY(first_obj -> x+5, first_obj -> y);

break;

// перемещение управляемого объекта влево

case GrKey_Left: case GrKey_a:

first_obj -> MoveXY(first_obj -> x-5, first_obj -> y);

break;

// перемещение управляемого объекта вверх

case GrKey_Up: case GrKey_w:

first_obj -> MoveXY(first_obj -> x,first_obj -> y - 5);

break;

// перемещение управляемого объекта вниз

case GrKey_Down: case GrKey_s:

first_obj -> MoveXY(first_obj -> x,first_obj -> y + 5);

break;

// поворот "пушки" против часовой стрелки

case GrKey_F1: case GrKey_PageUp: case GrKey_q:

first_obj -> TurnGun(1);

break;

// поворот "пушки" по часовой стрелке

case GrKey_F2: case GrKey_PageDown: case GrKey_e:

first_obj -> TurnGun(-1);

break;

// выстрел

case GrKey_Space:

// если с момента предыдущего выстрела

// прошло больше секунды

if (clock() - start > (clock_t) 1000) {

// смена цвета на серый

first_obj -> color = GrAllocColor(127, 127, 127);

// показ луча

first_obj -> LaserShow();

t = 0;

// цикл проверки попадений луча в объекты

for (i = 0; i < n; i++) {

x=first_obj->x+(first_obj->s)*cos(first_obj -> a);

y=first_obj->y-(first_obj->s)*sin(first_obj -> a);

// сканируем по лучу

for (j = first_obj -> s;

x < GrMaxX() && y < GrMaxY()

&& x > 0 && y > 0; j++) {

x = first_obj->x+j*cos(first_obj -> a);

y = first_obj->y-j*sin(first_obj -> a);

// если произошло попадание

if ((x > obj[i] -> x - obj[i] -> SizeX()) && (x < obj[i] -> x + obj[i] -> SizeX()) && (y > obj[i] -> y - obj[i] -> SizeY()) && (y < obj[i] -> y + obj[i] -> SizeY())) {

// добавляем номер объекта в массив объектов,

// подлежащих удалению,

// и увеличиваем количество таких объектов

del[t++] = i;

break;

}

}

}

// меняем цвет удаляемых объектов на красный

for (i = 0; i < t; i++){

obj[del[i]]->color = GrAllocColor(255, 0, 0);

obj[del[i]] -> Show();

}

GrSleep(100);

if (t != 0) {

// писк

Beep(600, 100);

GrSleep(1000);

}

// цикл удаления объектов и смещения указателей

for (i = 0; i < t; i++) {

delete obj[del[i] - i];

for (j = del[i] - i; j < n-i; j++){

obj[j] = obj[j + 1];

}

}

n -= t;

first_obj -> LaserHide();

} else {

first_obj -> color = GrAllocColor(127, 127, 127);

}

start = clock();

break;

}

}

} while(key != GrKey_Escape);

// удаление всех объектов

for(int i = 0; i < n; i++)

{

delete obj[i];

}

delete first_obj;

return 0;

}

Иерархия объектов



Блок-схема основной части программы

Размещено на Allbest.ru

...