Автор: admin

МИНИСТЕРСТВО ОБРАЗОВАНИЯ РОСИЙСКОЙ ФЕДЕРАЦИИ

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

Кафедра вычислительной техники

_____________________________________________________________________

Дистанционное обучение

2000 – 2001 учебный год

ОТЧЕТ

о выполнении практических заданий по курсу

ТЕХНОЛОГИЯ ПРОГРАММИРОВАНИЯ

Студента группы ВД – 49

Каретина Флориана Викторовича

Задание выполнил ________________ _____________________ подпись студента дата выполнения задания

Задание проверил ________________ _____________________ оценка подпись преподавателя

_______________________

дата проверки задания

Рецензия преподавателя

______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________

Описание программы созданной с помощью Turbo Visual.

Начинается программа с подключения библиотек Turbo Visual: uses App, Objects, Menus, Drivers, Editors, Views;
Основной блок программы состоит из трех команд:
Begin

MyApp.Init; {Подготовить работу программы}

MyApp.Run; {Выполнить необходимые действия}

MyApp.Done; {Завершить исполнение программы}
End.
Для создания собственной строки статуса вводим следующее описание: type

TMyApp=object(TApplication) {Создаем объект-потомок от TApplication} procedure InitStatusLine; virtual; {Перекрываем старый метод
InitStatusLine новым}
Описание нового метода, с помощью которого создается строка статуса:
Procedure TMyApp.InitStatusLine;
Var R:TRect; {хранит границы строки статуса}
Begin

GetExtent(R); {устанавливает R в координаты всего экрана}

R.A.Y:=R.B.Y-1; {передвигает вершину выше нижней на 1 строку}

StatusLine:=New(PStatusLine, Init(R, {создает строку статуса}

NewStatusDef(0,$FFFF, {устанавливает диапазон контекстного Help}

NewStatusKey(‘~Alt-X~ Exit’, kbAltX, cmQuit, {определяет элемент}

NewStatusKey(‘~Alt-F3~ Close’, kbAltF3, cmClose, {другой} nil)), {больше нет клавиш} nil))) {больше нет определений}
End;
Формирование меню:
Описание в разделе типов:
TMyApp=object(TApplication) {Создаем объект-потомок от TApplication} procedure InitMenuBar; virtual; {Перекрываем старый метод InitMenuBar новым}
Тело процедуры: procedure TMyApp.InitMenuBar;
Var R:TRect;
Begin

GetExtent(R); {устанавливает R в координаты всего экрана}

R.B.Y:=R.A.Y+1;

MenuBar:=New(PMenuBar, Init(R, NewMenu( {создать полосу меню}

NewSubMenu(‘~F~ile’, hcNoContext, NewMenu( {определить меню}

StdFileMenuItems(nil)), {стандратная функция определения элементов}

{меню
File}

NewSubMenu(‘~W~indow’, hcNoContext, NewMenu( {определить меню}

StdWindowMenuItems(nil)), {стандратная функция определения элементов}

{меню
Window} nil) {больше нет подменю}

)))); {конец полосы}
End;
Создание окон и манипуляции с ними:
Описание: procedure NewWindow; virtual; procedure HandleEvent(var Event:TEvent); virtual; end;

PDemoWindow=^TDemoWindow; {тип указателя для нового объектного типа}

TDemoWindow=object(TWindow) {определение нового типа окна} constructor Init(Bounds: TRect; WinTitle:String; WindowNo: Integer); end;

PInterior=^TInterior;

TInterior=object(TScroller) constructor Init(var Bounds:TRect; HS, VS: PScrollBar); procedure Draw; virtual; procedure HandleEvent(var Event:TEvent); virtual; end;
Описание тела конструктора инициализации окна: constructor TDemoWindow.Init(Bounds: TRect; WinTitle:String; WindowNo:
Integer); var

S:String[3];

Interior:PInterior;

HS, VS: PScrollBar; begin

Str(WindowNo,S); {устанавливает номер окна в заколовке}

TWindow.Init(Bounds, WinTitle+’ ‘+S, wnNoNumber);

GetClipRect(Bounds);

Bounds.Grow(-1,-1); {интерьер помещается внутри рамки окна}

VS:=StandardScrollBar(sbVertical+sbHandleKeyBoard); {разрешение перемещения вертикального бегунка стрелками на клавиатуре}

HS:=StandardScrollBar(sbHorizontal+sbHandleKeyBoard); {разрешение перемещения горизонтального бегунка стрелками на клавиатуре}

Interior:=New(PInterior, Init(Bounds, HS, VS));

Insert(Interior); {добавляет интерьер к окну} end;
Описание конструктора инициализации интерьера: constructor TInterior.Init(var Bounds:TRect; HS, VS: PScrollBar); begin

TScroller.Init(Bounds, HS, VS);

GrowMode:=gfGrowHiX+gfGrowHiY; end;
Описание процедуры прорисовки интерьера окна: procedure TInterior.Draw; begin

TScroller.Draw; {Вызов стандартной прорисовки}

WriteStr(0,0,’Текст в окне’,1); {Вывод текста в окно}

TScroller.ShowCursor; {Показать курсор} end;
Описание тела процедуры создания нового окна: procedure TMyApp.NewWindow; var

Window:PDemoWindow;

R: TRect;
Begin

Inc(WinCount);

R.Assign(0,0,26,7); {установка начального размера и позиции}

R.Move(Random(58),Random(16)); {случайное перемещение по экрану}

Window:=New(PDemoWindow, Init(R, ‘Demo Window’, WinCount));

DeskTop^.Insert(Window); {вывести окно на панель экрана}
End;
Описание тела процедуры обработки команд среды procedure TMyApp.HandleEvent(var Event:TEvent);
Begin

TApplication.HandleEvent(Event); {действует как предок} if Event.What=evCommand Then

Begin case Event.Command of {но откликается на дополнительные команды} cmNew: NewWindow; {определяет действие для команды cmNew} else

Exit;

End;

ClearEvent(Event); {очищает событие после обработки} end;
End;
Описание тела процедуры обработки команд в окне procedure TInterior.HandleEvent(var Event:TEvent);
Begin

TScroller.HandleEvent(Event); {действует как предок} case Event.What of {проверка события} evKeyDown: {если нажата клавиша}

Begin

Case Event.KeyCode of {проверка: какая клавиша нажата} kbLeft: {стрелка влево} begin if x>0 then {если координата по Х больше 0}

Begin x:=x-1; {то уменьшить ее на 1}

SetCursor(x,y); {установить на новую координату курсор}

End end; kbRight: {стрелка вправо} begin x:=x+1; {увеличить координату по Х на единицу}

SetCursor(x,y); {установить на новую координату курсор} end; kbUp: {стрелка вверх} begin if y>0 then {если координата по Y больше 0}

Begin y:=y-1; {то уменьшить ее на 1}

SetCursor(x,y); {установить на новую координату курсор}

End end; kbDown: {стрелка вниз} begin y:=y+1; {увеличить координату по Y на 1}

SetCursor(x,y); {установить на новую координату курсор} end; end;

Case Event.ScanCode of {проверка скан-кода клавиатуры}

57: {если пробел} begin

If GetState(sfCursorVis) Then {если курсор виден}

TScroller.HideCursor {то скрыть его}

Else

TScroller.ShowCursor; {иначе показать его} end; end;

End; end;
End;

Описание игровой программы «Стрельба по мишени».

Игровая программа состоит из трех процедур (minv — уменьшение кол-ва патронов, intro — заставка, go — конец игры) и основного блока программы.
Процедура minv (уменьшение количества патронов). kv:=kv-1; {уменьшение значение переменной kv (в основной программе она фигурирует как количество патронов) } setfillstyle(1,9); {установка стиля заполнения фона} bar((20-kv)*10+415,4,(20-kv)*10+425,12); {стирание одного патрона с экрана}
Процедура intro; {Заставка}
Выводит заставку игры. settextstyle(0,0,15); {установка стиля текста} setcolor(12); {установка цвета} outtextxy(140,100,’ТИР’); {вывод текста} settextstyle(0,0,2); setcolor(10); outtextxy(130,290,’ESC — ‘); setcolor(14); outtextxy(220,290,’Выход из программы’); settextstyle(0,0,1); tp:=’НАЖМИТЕ ЛЮБУЮ КНОПКУ ДЛЯ НАЧАЛА ИГРЫ’; settextstyle(0,0,1); setcolor(11); outtextxy(320-trunc(length(tp)*4),340,tp); {вывод текста с расчетом по центру} a:=readkey; if ord(a)=27 then exi:=true; {если нажата клавиша Esc – выйти из игры} setfillstyle(1,0); bar(100,30,600,350);
Процедура go – выводит заставку конца игры procedure go; {Конец игры} begin settextstyle(0,0,5); {установка стиля вывода текста} setcolor(2); {установка цвета} outtextxy(50,200,’ВСЕ,ДОИГРАЛИСЬ’); settextstyle(0,0,2); readkey;
UROV:=1;MENU:=true;oko:=0; end;
Основное тело программы begin d:=vga;initgraph(d,r,»); {инициализация графики} setgraphmode(2); {установка графического режима} randomize; {вызов генератора случайных чисел} urov:=1;oko:=0; mus:=true; sou:=true;menu:=true; {первоначальная установка переменных} repeat {начало основного цикла программы}
{Cоздание интерфейса} cleardevice; {очистака экрана} setfillstyle(1,1); {установка стиля заполнения фона} bar(0,0,640,2); {рисование прямоугольников вокруг рабочей области} bar(0,0,2,480); bar(0,480,640,478); bar(640,480,638,0); setfillstyle(1,9); bar(2,2,638,17); bar(2,2,5,478); bar(2,478,638,475); bar(638,2,635,478); setfillstyle(1,3); bar(5,17,635,19); bar(5,17,7,475); bar(5,475,635,473); bar(635,17,633,475); setfillstyle(9,14); setcolor(14); {установка цвета рисования} moveto(7,460); {перемещение графического курсора в указанные координаты} for i:=1 to 62 do {рисование песка холмиками} lineto(i*10+7,460+random(10)); lineto(633,460); line(7,473,633,473); line(7,473,7,460); line(633,473,633,460); floodfill(9,469,14); {заполнение стилем области, расположенной либо внутри замкнутого контура, либо вне его} setlinestyle(0,0,1); {установка стиля линий} setfillstyle(8,6); {установка стиля заполнения фона} bar(260,408,380,470); setfillstyle(1,1); setcolor(14); line(260,408,260,470); line(260,408,380,408); line(380,408,380,470); fillellipse(320,408,23,15); {вычерчивание контура эллипса текущим цветом и заполнение ограниченной контуром области экрана текущим узором} setlinestyle(0,3,3); setcolor(11); line(320,391,320,376); fi:=pi;tzm:=40;tzs:=40; settextstyle(0,0,2); cou:=0; kv:=20; ov:=1; ex:=0; setfillstyle(1,15);setcolor(7); bar(250,6,310,12); setfillstyle(1,0); bar(17,2,220,17); setcolor(12); outtextxy(20,3,’Cчет:’); setcolor(11); setfillstyle(1,11); for i:=1 to kv do fillellipse(i*10+420,8,3,3); {рисование патронов} if menu then intro; {если menu=true, то вызвать процедуру intro (заставка игры)} menu:=false; if exi then goto 1; {если exi=true (выход), то перейти на метку 1} repeat if keypressed then a:=readkey; settextstyle(0,0,1); outtextxy(280,280,’Нажмите ENTER’); setcolor(random(16)); settextstyle(0,0,2); str(urov,em); outtextxy(270,200,concat(‘УРОВЕНЬ ‘,em)); {вывод текста с помощью процедуры конкатенации} str(urov*1000,em); outtextxy(190,240,concat(‘Наберите ‘,em,’ очков’)); until ord(a)=13; {выход из цикла по клавише Enter} setfillstyle(1,0); bar(180,200,500,300); gettime(q1,min,sec,q2); {получение системного времени} mk:=min+1; {увеличение минут на 1} sk:=sec; if mk>=60 then begin {если количество минут больше 60,} hk:=q1+1; {то количество часов увеличить на 1} mk:=0; {минуты обнулить} end; repeat gettime(q1,min,sec,q2); {получение системного времени} setfillstyle(1,1); {установка стиля заполнения} setcolor(4); {установка цвета рисования} if mk=min then rk:=60-abs(sk-sec) else rk:=abs(sk-sec); bar(250,6,250+abs(rk),12); if not(bm) then begin gettime(q1,min,sec,q2); {получение системного времени} po:=random(3); if sec+po>=59 then begin tpm:=min+1; tps:=0; end else begin tpm:=min; tps:=sec+po; end; end; xnp:=round(sin(fi)*24+320); ynp:=round(cos(fi)*15+406); xkp:=round(sin(fi)*38+320); ykp:=round(cos(fi)*30+406); setlinestyle(0,3,3); setcolor(11); line(xnp,ynp,xkp,ykp); ok:=false; if keypressed then begin a:=readkey; if a=chr(77) then begin fi:=fi-0.05; ok:=true; end; {Поворот дула влево} if a=chr(75) then begin fi:=fi+0.05; ok:=true; end; {Повоорт дула вправо} if ord(a)=27 then menu:=true; {Выход в меню} if fi3*pi/2 then fi:=3*pi/2; if a=’ ‘ then begin {Выстрел} if (not(fire.v)) and (not(ok)) then begin minv; for d:=1 to 100 do begin if sou then sound(random(200)+100);delay(1); end; nosound; fire.v:=true; fire.r:=35; fire.si:=sin(fi)*1.1; fire.co:=cos(fi); ok:=true; fire.xs:=-10; fire.ys:=-10; end; s:=s+1; end; end; if (kv=0) and (not(fire.v)) then ex:=ex+1; if fire.v then begin {Полет снаряда} setfillstyle(1,0); setcolor(0); bar(fire.xs-4,fire.ys-4,fire.xs+4,fire.ys+4); xv:=round(fire.si*fire.r+320); yv:=round(fire.co*fire.r+406); fire.r:=fire.r+5; fire.xs:=xv;fire.ys:=yv; if (fire.xs=622) or (fire.ys=tps) and not(mn) then begin bm:=true;mn:=true; xm:=random(560)+30; ym:=random(320)+30; vm:=random(2)+3; if vm+sec>=59 then begin tzm:=min+1; tzs:=abs(vm+sec-60); end else begin tzm:=min; tzs:=vm+sec; end; repeat nch:=random(5)+1; mi:=20+nch*5; {Размер мишени} until nch=tzm) and (sec>=tzs) then begin bm:=false;mn:=false; setfillstyle(1,0); bar(xm,ym,xm+mi,ym+mi);xm:=-1300;ym:=-1300; end; if ok then begin setcolor(0); line(xnp,ynp,xkp,ykp); end; until (ord(a)=27) or (ex=1) or ((mk=min) and (sec>=sk)); oko:=oko+cou; str(oko,em); bm:=false;mn:=false;fire.v:=false; if cou

Министерство образования и науки Российской Федерации

Армавирский государственный педагогический университет

Кафедра информатики и информационных технологий обучения

КУРСОВАЯ РАБОТА

ПО ИНФОРМАТИКЕ

Тема работы: „ Моделирование игровых программ

средствами Delphi ”

Автор работы: студентка
303 группы МФ

Татарникова Людмила
Владимировна

Научный руководитель: доцент Неверов

Александр
Владимирович

Оценка:____________________________

Армавир

2004 г.

Содержание

Введение 3

Этапы разработки проекта 4

Заключение 13

Список литературы .14

Приложение ……………………………………………………………………………….15

Введение

Система Delphi является одной из лучших разработок в современной теории и практики программирования. Как любая подобная система, Delphi предназначена для разработки программ и имеет две характерные особенности: создаваемые ею программы могут работать не только под управлением Windows, а сама она относится к классу инструментальных средств ускоренной разработки программ. Это ускорение достигается за счет следующих свойств
Delphi: визуального конструирования форм и широкого использования библиотеки визуальных компонентов.

Визуальное конструирование форм избавляет программиста от многих аспектов разработки интерфейса программы, так как Delphi автоматически готовит необходимые программные заготовки и соответствующий файл ресурсов.
При создании программ используется специальное окно, которое называется окном формы, как прототип будущего окна программы, оно наполняется компонентами, реализующими нужные интерфейсные свойства (разного рода списки, кнопки, полосы прокрутки и т. п.). Компоненты находятся в библиотеке визуальных компонентов. Она предоставляет программисту огромное разнообразие программных заготовок, которые немедленно или после несложной настройки готовы к работе в рамках программы. Использование компонентов не только во много раз уменьшает сроки разработки программ, но и существенно снижает вероятность случайных программных ошибок.

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

Целью данной курсовой работы является создание одной из таких игр в среде программирования Delphi 6. Игра носит название „Собери картинку”. Она служит аналогом игры „15”, только игрок перемещает не цифры, а фрагменты картинки.

Этапы разработки проекта

Моделирование игры „Собери картинку” проходит ряд этапов. Их выполнение гарантирует достижение поставленной цели.

1.В Delphi 6 создать новый проект под названием „Soberi”.
Установить основные свойства окна формы:

Left = 239

Top = 185

BorderIcons = [biSystemMenu]

BorderStyle = bsSingle

Caption =Собери картинку

ClientHeight = 254

ClientWidth = 255

Color = clBtnFace

Font.Charset = DEFAULT_CHARSET

Font.Color = clWindowText

Font.Height = -11

Font.Name = ‘MS Sans Serif’

Font.Style = []

Menu = MainMenu1

OldCreateOrder = False

OnCreate = FormCreate

OnMouseDown = FormMouseDown

OnPaint = FormPaint

PixelsPerInch = 96

TextHeight = 13.

2.Создать процедуру по созданию формы (обработка события OnCreate):

procedure TForm1.FormCreate(Sender: TObject) (стр.21)
Для ее выполнения необходимо внести в программу следующие процедуры:

procedure TForm1.Formmas (стр.18) procedure TForm1.NewGame (стр.17)

Процедура Formmas формирует массив клеток игрового поля. NewGame позволяет загружать картинку ‘pic_1.bmp’ из внешнего растрового файла, если при обращении к файлу происходит ошибка, то форма закрывается. Также при выполнении этой процедуры устанавливается размер формы, равный размеру картинки. Картинка разрезается на фрагменты, которые перемешиваются
(процедура Mixer стр.20) и отображаются на форме (процедура ShowPole стр.19). Для перемешивания 150 раз случайным образом выбирается фрагмент изображения, находящийся рядом с пустой клеткой и перемещается в эту пустую клетку. Для отображения фрагментов на форме задаются прямоугольные области, на канву которых копируются части изображения. Форма приобретает вид:

[pic]

3. Создать процедуру по обработке события OnMouseDown: procedure TForm1.FormMouseDown(Sender: TObject; Button:
TMouse Button; Shift: TShiftState; X, Y: Integer) (стр.19)

Она позволяет при нажатии на кнопку мыши вычислять номер фрагмента, на котором сделан щелчок. Далее необходимо создать процедуру Move
(стр.18). В ней проверяется, свободна ли одна из соседних клеток. Если да, то этот фрагмент стирается и заново отображается в соседней клетке. Каждому фрагменту изображения поставлен в соответствие его порядковый номер. Это позволяет проверить, собраны ли номера в нужном порядке, то есть собрана ли картинка целиком. Для этого нужно создать функцию Finish (стр.17), которая будет выполнять эту проверку. Если картинка собрана, то на пустую клетку копируется последний фрагмент изображения. На экран выводится сообщение „
Цель достигнута! ” Игрок имеет возможность сыграть еще раз, выбрав „Yes ”, если он выбирает „ No ”, то программа завершает свою работу.

4. Разместить на форме компоненты MainMenu1 и OpenPictureDialog1 из страниц Standart и Dialog соответственно. Создать главное меню программы
(двойной щелчок мышью по MainMenu) следующей структуры:

Игра |Уровень |Справка | |Новая |Простой |Правила игры | |Набор картинок

|Средний |О программе | |Выход |Сложный | | |
Тогда форма примет вид:

[pic]

5. Создать процедуру для пункта меню игра – новая: procedure TForm1.N2Click(Sender: TObject) (стр.22 )

Эта процедура позволяет игроку начать игру сначала. Картинка снова разрезается на фрагменты, которые перемешиваются и отображаются на форме.

6. Для пункта набор картинок нужно сделать следующее: заполнить компонент OpenPictureDialog файлами с изображениями формата bmp, затем создать процедуру (щелчок мышью по набор картинок) procedure TForm1.N3Click(Sender: TObject) (стр.22 ), которая даст возможность выбирать эти изображения во время игры.

Таким образом, программа будет работать для картинки, загружаемой во время старта программы, а также позволит загружать произвольные изображения формата bmp.

7.

Программируем пункт меню выход: procedure TForm1.N11Click(Sender: TObject) (стр.21 )
Эта процедура обеспечивает выход из игры.

8. Чтобы была возможность выбора уровня игры, необходимо создать следующие процедуры: для пункта простой — procedure TForm1.N8Click(Sender: TObject) (стр.22 ); для пункта средний — procedure TForm1.N9Click(Sender: TObject) (стр.22 ); для пункта сложный — procedure TForm1.N10Click(Sender: TObject) (стр.23).

Уровни зависят от количества фрагментов, на которые разбивается картинка.

[pic]

Простой уровень Средний уровень

[pic]

Сложный уровень

9. Чтобы игрок мог ознакомиться с правилами игры, выбрав в меню пункт правила игры, необходимо сделать следующее:

. В программе Word Pad набрать текст, содержанием которого являются правила игры „ Собери картинку ”, сохранить его в файле формата rtf под названием „Правила”. Полученный файл сохранить в папке, где находится проект Soberi.

. Создать новую форму Form3;

. Разместить на форме объекты: Button1 и Panel1 из страницы Standart и

RichEdit1 из Win32;

. Изменить некоторые свойства объектов:

Для Panel1:

Align – alBottom.

Для Button1:

Caption – Закрыть.

Для RichEdit1:

Align – alClient;

ScrollBars – Vertical;

Форма будет иметь вид:

[pic]

. Командой Use Unit (Alt+F11) добавить к основной программе Unit3, связанный с Form3;

. Создать процедуру для пункта правила игры (щелчок мышью по правила игры): procedure TForm1.N6Click(Sender: TObject) (стр.22 )

Эта процедура выводит на экран форму Form3 и помещает на ее компонент

RichEdit содержимое текстового файла „ Правила ”. Форма принимает вид:

[pic]

Таким образом, игрок получает возможность ознакомиться с правилами игры

10. Каждая пользовательская программа должна содержать сведения о том, кто является ее автором, где и когда она была разработана. Эти данные будут находиться в пункте меню о программе. Чтобы их туда поместить, необходимо выполнить следующие действия:

. Создать новый проект Progr_ и сохранить его в папке, в которой находится проект Soberi;

. Разместить на форме несколько объектов: Label1, Label2, Button1,

Panel1, Image, выбрав их на страницах Standart и Additional;

. Изменить некоторые свойства формы и размещенных компонентов: для Form1:

Name – Form2;

Caption – О программе Soberi_;

BorderIcons: biMaximize – False; biMinimize – False; biSystemMenu – False.

Для Lable1:

Caption – Курсовая работа по теме: „Моделирование игровых программ средствами Delphi”;

WordWrap – True;

Alignment – taCenter.

Для Label2:

Caption – Выполнила студентка 3 курса математического факультета

Татарникова Л. В.;

WordWrap – True;

Alignment – taCenter.

Для Panel1:

Caption – Армавир 2004;

BevelInner – byLowered;

BevelOuter – byRaised;

Для Button1:

Caption – Закрыть.

. На компонент Image следует скопировать изображение, которое может быть произвольным, т. е. по желанию пользователя.

В результате форма примет вид:

[pic]

. Для кнопки Button1 написать процедуру: procedure TForm2.Button1Click(Sender: TObject) begin close; end.

Эта процедура позволяет при нажатии на кнопку закрывать форму.

. Полученный проект Progr_ добавляем в первоначальный проект Soberi;

. Пункт меню о программе программируем следующей процедурой: procedure TForm1.N7Click(Sender: TObject) (стр.21).

При вызове этого пункта на экран будет выводиться окно формы из проекта

Progr_, которое содержит основные сведения о проекте Soberi.

11. Заключительный этап, на котором следует запустить проект.

Заключение

В результате выполнения курсовой работы в среде программирования
Delphi 6 была смоделирована логическая игра под названием „Собери картинку”. Игра содержит меню, используя которое можно выбирать различные виды картинок, также существует возможность устанавливать уровень сложности, который предпочитает игрок. Если есть необходимость ознакомиться с правилами игры, то их тоже можно найти в главном меню, там же находится основная информация о программе.

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

Список используемой литературы:

1. Архангельский А. Я. Интегрированная среда разработки Delphi –
М.:ЗАО, Бином; 1999.

2. Марко Кэнту для профессионалов Delphi 6: изд. Питер, 2002.

3. Фаронов В. В. DELPHI 6: Учебный курс (+ дискета) – СПб: Питер,
2002.

Приложение

Текст программы

unit Soberi_; interface uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms,
Dialogs, Menus, ExtDlgs;

type
TForm1 = class(TForm)

MainMenu1: TMainMenu;

N1: TMenuItem;

N2: TMenuItem;

N3: TMenuItem;

N4: TMenuItem;

N5: TMenuItem;

N6: TMenuItem;

N7: TMenuItem;

N8: TMenuItem;

N9: TMenuItem;

N10: TMenuItem;

N11: TMenuItem;

OpenPictureDialog1: TOpenPictureDialog; procedure FormCreate(Sender: TObject); procedure FormMouseDown(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer); procedure FormPaint(Sender: TObject);

procedure ShowPole; procedure Mixer; procedure NewGame; procedure Formmas; procedure N11Click(Sender: TObject); procedure N7Click(Sender: TObject); procedure N2Click(Sender: TObject); procedure N3Click(Sender: TObject); procedure N6Click(Sender: TObject); procedure N8Click(Sender: TObject); procedure N9Click(Sender: TObject); procedure N10Click(Sender: TObject); private

{ Private declarations } public

{ Public declarations } end; var
Form1: TForm1;

implementation

uses Progr, Unit3;

{$R *.dfm}

var wc,hc,h,w: integer;fname: string; pole: array of array of byte; ex, ey:integer; stp: array of array of byte;
{(1, 2, 3, 4),(5, 6, 7, 8), (9, 10, 11, 12), (13, 14, 15, 0)} pic: TBitmap; procedure TForm1.NewGame; var i, j:integer; begin try pic.LoadFromFile(fname); except on EFopenError do begin

ShowMessage(‘Ошибка обращения к файлу’ + fname);

Form1.Close; end; end; hc:=Pic.Height div H; wc:=Pic.Width div W;
ClientWidth:= wc * W;
ClientHeight:= hc * H; for i:=1 to H do for j:=1 to W do pole[i,j]:= stp[i,j];
Form1.Mixer;
Form1.ShowPole; end; function Finish: boolean; var row,col: integer; i: integer; begin row:=1; col:=1;

Finish:= True; for i:=1 to 15 do begin if pole[row,col] i then begin

Finish:=False; break; end; if col < 4 then inc(col) else begin col :=1; inc(row); end; end; end; procedure TForm1.Formmas; var i,j:integer; begin
SetLength(stp,H+1,W+1);
SetLength(pole,H+1,W+1); for i:=1 to H do for j:=1 to W do stp[i,j]:=h*(i-1)+j; stp[H,W]:=0 end; procedure Move(cx, cy:integer); var r:integer; begin if not (( abs(cx-ex)=1) and (cy-ey=0) or

( abs(cy-ey)=1) and (cx-ex=0)) then exit;

Pole[ey,ex]:=Pole[cy,cx];

Pole[cy,cx]:=0; ex:=cx; ey:=cy;

Form1.ShowPole; if Finish then begin pole[H,W]:=H*W;

Form1.ShowPole; r:=MessageDlg(‘Цель достигнута!’+ #13+

‘Еще раз?’, mtInformation, [mbYes, mbNo], 0); if r = mrNo then Form1.Close;

Form1.NewGame; end; end; procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer); var cx,cy:integer; begin cx:= Trunc(X / wc) + 1; cy:= Trunc(Y / hc) +1;
Move(cx, cy); end; procedure TForm1.ShowPole; var
Source, Dest: Trect; sx, sy: integer; i,j: integer; begin for i:=1 to W do for j:=1 to H do begin sy:=((pole[i,j]-1) div W)*hc; sx:=((pole[i,j]-1) mod W)*wc;

Source:=Bounds(sx,sy,wc,hc);

Dest:=Bounds((j-1)*wc,(i-1)*hc,wc,hc); if pole[i,j] 0 then Canvas.CopyRect(Dest,pic.Canvas,Source) else Canvas.Rectangle((j-1)*wc,(i-
1)*hc,j*wc,i*hc); end; end; procedure TForm1.Mixer; var x1,y1: integer; x2,y2: integer; d: integer; i: integer; begin x1:=H; y1:=W; randomize; for i:=1 to 150 do begin repeat x2:=x1; y2:=y1; d:=random(4)+1; case d of

1: dec(x2);

2: inc(x2);

3: dec(y2);

4: inc(y2); end; until (x2>=1) and (x2=1) and (y2

МИНИСТЕРСТВО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ

ДАЛЬНЕВОСТОЧНЫЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

КОНТРОЛЬНАЯ РАБОТА

по дисциплине:

«Создание приложений средствами MS Access»

на тему:

«Домашняя фонотека»

Владивосток 2009

Содержание

1. Общие положения

2. Задачи, решаемые в рамках рассматриваемой предметной области

3. Концептуальная модель

4. Реляционная модель данных

5. Запросы

6. Формы

8. Отчеты

9. Макросы

10. Руководство для пользователя по применению базы данных

Заключение

Список используемой литературы

Введение

В данной курсовой работе рассматривается новый программный продукт «Access-2000» (MICROSOFT) – популярная программа разработки реляционных Баз Данных, которая входит в состав пакета Microsoft Office 2000. Данная База Данных создана для облегчения учета домашней фонотеки на разных информационных носителях. Одно из мощных средств базы данных состоит в том, что информацию можно упорядочить по тому признаку, который задает пользователь.

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

1. Общие положения

У многих людей есть хобби и увлечения. Одним из них является увлечение музыкой. В ходе этого приобретается большое количество различных носителей музыкальной информации: диски, кассеты, пластинки. И со временем любая коллекция разрастется до невероятных размеров. Назревает необходимость в учете и в общем анализе всей той информации которая накопилась в рамках существующей коллекции. Все эти проблемы и позволяет решить созданная База Данных.

2. Задачи, решаемые в рамках рассматриваемой предметной области

Автоматизированная информационная система решает следующие задачи:

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

С помощью созданной Базы Данных можно будет получить ответы на следующие вопросы:

Образцы какой музыки содержаться в данной коллекции?

Узнать имена исполнителей и альбомов?

В каком виде храниться музыкальная информация (CD, DVD, MP-3)?

Кому и когда был отдан тот или иной альбом, и когда его должны отдать?

В каком магазине был приобретен тот или иной диск?

3. Концептуальная модель

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

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

4. Реляционная модель данных

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

Таблица 1. Альбомы

Таблица 2. Выдача-возврат

Таблица 3. Магазин

Таблица 4. Тип носителя

Таблица 5. Пользователи

5. Запросы

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

В базе данных данной курсовой работы используются следующие запросы:

Запрос «Должники»

Данный запрос является параметрическим (т.е. запросом с изменяемыми условиями). По полям «Дата выдачи», «Дата возврата» и «Ф.И.О. Пользователя» задаем параметрические условия.

Данный запрос позволяет определить, кто из пользователей должен вернуть

Тот или иной альбом.

Запрос «Альбомы»

Данный запрос является параметрическим запросом на выборку. По полям «Наименование», «Исполнители», «Год альбома» и т.д. задаем параметрические условия. Данный запрос позволяет узнать наименование альбома, исполнителя, год выпуска, где был приобретен.

6. Формы

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

В данной Базе Данных в наличие имеются следующие формы:

«Фонотека»

2 «Магазин»

3 «Движение фонотек»

4 «Карточка пользователя»

5 «Кнопочная форма»

Формы под номером 1 и 2 используются непосредственно для добавления данных. Для построения этих форм используются данные из таблиц «Альбомы» и «Магазины» соответственно. На данных формах имеются ряд кнопок, таких как:

– «Первая запись»

– «Предыдущая запись»

– «Следующая запись»

– «Последняя запись»

– «Добавить запись»

– «Выйти из формы»

А так же имеется ряд кнопок для быстрого перехода в другие формы такие как:

– Позволяет перейти в форму «Карточка пользователя»

– Позволяет перейти в форму «Магазины»

– Позволяет перейти в форму «Главная кнопочная форма»

– Позволяет перейти в форму «Движение фонотек»

Главной задачей для форм под номером 3 и 4 является просмотр и корректировка (внесение изменений в существующие данные) данных о движении фонотек и данные о том кому была передана фонотека. В качестве исходных данных используются таблицы: «Выдача-возврат», «Пользователи».

Кнопки в этих формах работают так же как и в формах 1 и 2.

Главная кнопочная форма является как бы обложкой базы данных. Именно с ней непосредственно работает пользователь и получает возможность доступа к объектам базы данных. Это обыкновенная форма с кнопками, обеспечивающими возможность открытия других форм. Создать кнопочную форму позволяет специальное средство Access – диспетчер кнопочных форм.

Главная кнопочная форма состоит из четырех страниц:

Первая страница создается по умолчанию диспетчера – главная страница

Движение фонотек

Карточка пользователя

Магазин

Фонотека

8. Отчеты

В MS Access получать твердые копии результатов обработки данных можно путем распечатки таблиц, запросов и форм, представленных в виде отчетов. Отчет – это тип объектов в Access, который используется для просмотра и печати данных. Отчет создается в тех случаях, когда необходимо наглядно представить на экране или на бумаге сводную информацию, хранящуюся в Базе Данных. Главное назначение отчета – формирование выходных документов, которые будут представлять собой копию форм реальных документов предприятия, с которыми непосредственно работает пользователь.

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

В данной курсовой работе представлены два отчета:

Альбомы

Должники

Данные отчеты построены на основании данных трех таблиц: «Альбомы», «Выдача возврат», «Пользователи». Такого рода отчеты носят название многотабличных отчетов. Данные отчеты представлены в виде таблиц с занесенными в них данными.

Созданные отчеты будут распечатываться по мере надобности

9. Макросы

Макросы – это небольшие программы, в которых содержатся макрокоманды Access (для которых можно определить условие, если условие выполняется, то выполняется и сама макрокоманда), предназначенные для выполнения одного или нескольких действий. Макрос можно запускать из окна базы данных или связывать с событием.

Основным назначением макроса является создание элементов для пользовательского интерфейса.

В данной базе данных содержатся следующие макросы:

1. Открыть движение фонотек.

2. Открыть фонотеку.

Данные макросы связаны с кнопками на формах.

Каждая кнопка имеет свой значок и «всплывающую» подсказку, которые позволят пользователю без труда понять о назначении данных кнопок.

10. Руководство для пользователя по применению базы данных

Для успешной работы с созданной Базой Данных необходимо знать следующую информацию:

Главный элемент, с которого начинается работа с базой данных, и который Вы увидите при открытии базы данных, – главная кнопочная форма. Она необходима для открытия форм и отчетов. На ней находятся следующие кнопки:

Открытие формы «Фонотека» – позволяет перейти к форме «Фонотека»

Открытие формы «Движение фонотек» – позволяет перейти к форме «Движение фонотек»

Открытие формы «Карточка пользователя» – позволяет перейти к форме «Карточка пользователя» и внести необходимые коррективы.

Выход из базы данных – непосредственный выход из базы данных. Также выйти из базы данных можно, нажав на кнопку с изображением открытой двери, которая находится на панели элементов.

При нажатии кнопки «Фонотека» открывается форма «Фонотека». На ней находятся следующие кнопки:

Кнопки управления, которые позволяют просматривать, а так же добавлять новые записи.

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

Переход на главную кнопочную форму – позволяет перейти к главной кнопочной форме.

Заключение

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

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

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

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

Список используемой литературы

Рубен А., Горев А., Макашарипов С. Эффективная работа с СУБД. – СПб: Питер, 1997

Пасько В. Access 97. – Киев: BHV, 1997

Робинсон С. MS Access 2000. – СПб: Питер, 2001

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

КАФЕДРА ИНФОРМАТИКИ

Курсовая работа по информатике

Выполнили: студентка 2 курса

Гойтина Ю.В.

Руководитель: ст. преподаватель

Гусева Е. Н.

СОДЕРЖАНИЕ

ВВЕДЕНИЕ……………………………………………………………3

1. РАЗРАБОТКА ИГРОВОЙ ПРОГРАММЫ НА ПРИМЕРЕ

ИГРЫ «SIEGE»………..……………….…………………………….. 5

1. СПЕЦИФИКАЦИЯ ИГРОВОЙ ПРОГРАММЫ

«SIEGE»……….……………………………………………………… 9

1. СТРУКТУРНАЯ ДИАГРАММА…..…………………………… 11

3.1 Описание назначения модулей……..………………………11

ЗАКЛЮЧЕНИЕ…………………..…………………………………. 13

СПИСОК ЛИТЕРАТУРЫ…………………………………………. 14

ПРИЛОЖЕНИЕ……………………………………………………… 15

ВВЕДЕНИЕ
Большинство пользователей, как опытных, так и начинающих, не без удовольствия играют в компьютерные игры. Компьютерные игры сравнительно молодое явление, обладающие достаточно богатой со своими падениями и взлетами. Их история началась не с конца 1970 годов. Начало лежит гораздо раньше. На самом деле все начиналось с модели железной дороги, на основе которой появились предпосылки для дальнейшего развития первых компьютерных игр.
Игры дают нам шанс расслабиться играя, сбросить стресс. Что они делают лучше всего, так это создают альтернативные реальности, в которые можно погрузиться. Иногда эти реальности пытаются повторить наш реальный мир. И иногда они могут перенести нас в полностью враждебный или фантастический мир. От управления реактивным истребителем до управления командой
Национальной Футбольной лиги, от сражения с драконами до создания новых миров, постройки дорог, исследование космоса, до всего, что может изобрести наше воображение.
Указать точное число компьютерных игр очень трудно. Можно только примерно оценить число различных наименований игр, находящихся на рынке в любое время.
Компьютерная игра – один из наиболее популярных видов программного обеспечения, давший начало целому направлению – игровой информатике.
Несмотря на многообразие подобных программ, все игры могут быть разделены на следующие виды:
1. Обучающие
1. Развивающие
1. Деловые
1. Развлекательные
2. Комбинированные
Целью нашей курсовой работы является изучение основных положений теории игр, а также разработка игровой программы на языке программирования Turbo
Pascal.
Проектирование игрового продукта состоит из нескольких этапов:
1. Определения класса игры. На данном этапе необходимо сформулировать правила игры.
1. Выделение компонентов игры.
1. Определение иерархического уровня игры:
А) оперативный
Б) тактический
В) стратегический
1. Разработка дизайна игры.
1. Разработка интерфейса игры.
Чтобы достигнуть поставленной цели необходимо решить задачи, связанные психологической областью (использование палитры, образы на экране) и областями теории игр, а также задачи, связанные с областью программирования
(изучение графических возможностей Turbo Pascal).

1.РАЗРАБОТКА ИГРОВОЙ ПРОГРАММЫ НА ПРИМЕРЕ ИГРЫ «SIEGE»

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

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

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

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

В нашей игре также существуют свои правила – используя клавиши управления курсором играющий может последовательно передвигать героя на протяжении всей стены. Он должен сбрасывать камни на своих врагов, находясь именно над теми врагами, на которые нужно сбросить камень.Чтобы перейти на слудующий уровень ему нужно уничтожить определенное количество врагов. При этом ни один из врагов не должен добраться до верха стены, в противном случае игра будет закончена.
В теории игр существуют 2 широких класса компьютерных игр:
1. игры с преобладанием роли;
1. игры с преобладанием правил;
Игры с преобладанием роли можно разделить на следующие подклассы:
V сюжетно-ролевые;
V деловые;
V организационно-деятельностные;
V имитационные;
Игры с преобладанием правил можно разделить на:
V дидактические;
V развивающие;
V спортивные;
V военные;
V азартные;

Игра «Siege» относится к играм, в которых преобладают правила. В данной игре не предусматривается то, что играющий может изменять и вводить свои правила на всем ее протяжении . Во время игры играющему необходимо принимать решения: в каком направлении нужно двигать героя вдоль стены и останавливать его в определенном месте для сбрасывания камней.
Можно выделить следующие составляющие при разработке компьютерной игры:
V цель
V игровую среду
V взаимодействие с играющим
V оценку игровой ситуации

Целью является прохождение всех уровней игры, а средством – выбор правильных действий для достижения нужного результата.

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

И г р о в а я с р е д а – совокупность связей объектов в игре и правил их изменения.

В игре «Siege» в качестве игровой среды выступает стена с героем и врагами. Во время игры герой уничтожает врагов, сбрасывая на них камни.
Когда герой уничтожает врагов, он попадает на уровень выше. Если герой не успеет сбросить камень на какого — либо врага либо пройдет все уровни, игра заканчивается. По мере прохождения каждого уровня игры увеличивается скорость и количество врагов.
В з а и м о д е й с т в и е с и г р а ю щ и м – совокупность средств, предоставляемых для изменения игровой среды.

В нашей игре при помощи клавиш управления курсором можно изменить напрвление движения героя, движущегося вдоль стены. Должна учитываться быстрота реакции на быстро движущихся и появляющихся в разных местах врагов.
О ц е н к а и г р о в о й с и т у а ц и и — соотношения и условия, которые определяют цель поведения играющего.
В игре «Siege» начальное положение героя – середина верхней части стены.
Задачей игрока является то, что он, должен уничтожить всех врагов. Находясь в разных положениях, он должен передвигаться именно в то место, где находится враг и сбрасывать на него камень.

Этап создания компьютерной программы начинается только после выбора сюжета, способов взаимодействия с играющим и системы критериев оценки поведения играющего, описания игровой среды. Игровая программа состоит из двух частей: первая реализует внутреннюю, логическую структуру компьютерной игры, т. е. отображает игру в системе машинных данных и алгоритмов, вторая
— отображает процесс игры на терминале.

Основную роль любой компьютерной игры составляет логическая структура, в которой выделяют три уровня – оперативный, тактический и стратегический.

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

Т а к т и ч е с к и й у р о в е н ь определяется как совокупность игровых действий, ведущих к достижению какой-либо локальной цели. В результате действия тактического плана играющий достигает улучшения (или ухудшения) положения в игре.

С т р а т е г и ч е с к и й у р о в е н ь предполагает планирование всей игры, которая должна строиться так, чтобы достичь цели и добиться выигрыша.

В игре «Siege» можно выделить все три уровня, но преобладает тактический, так как от играющего требуется принимать решения, куда переместить героя в быстроменяющейся ситуации.

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

Среди множества вариантов интерфейса человек-компьютер есть два принципиально отличных вида:
1. «вспоминай-и-набирай» — это язык команд, которые сначала надо вспомнить, потом набрать и выполнить;
1. «смотри-и-выбирай» — это язык всевозможных меню и пиктограмм, в котором следует выбрать необходимое, после чего произойдет соответствующее действие.

Мы в нашей курсовой работе использовали второй вид интерфейса человек-компьютер для разработки меню игры.
В игре «Siege» мы использовали стандартные средства для работы с графическими изображениями языка программирования Турбо Паскаль. Диалог между компьютером и играющим осуществляется как в меню, так и во время самой игры.

2. СПЕЦИФИКАЦИЯ ИГРОВОЙ ПРОГРАММЫ «SIEGE»

1. Название задачи
Компьютерная игра.
Название программы – «Siege».
Система программирования Turbo Pascal.
1. Описание
Игра начинается с заставки, где написано название игры. Затем следует главное меню, где пользователь может выбрать один из трех пунктов меню:
«Play the game», «Instruction», «Story», «Exit to DOS». Если пользователь выбирает первый пункт меню, то после предисловия он может начать игру.
Если он выбирает – второй, то можно ознакомиться с инструкцией. Если он выберет третий пункт, то он может прочитать предысторию. Иначе пользователь может выйти из игры. Игрок должен успеть сбрасывать камни на своих врагов, пока они не добрались до верха стены. При неудачном окончании игры, если враг достиг героя, игра заканчивается и выдается сообщение — «Game Over».
При выигрыше, если пользователь прошел десять уровней, то он может выйти из игры.
3. Управление режимами работы программы
Игра осуществляется с помощью меню.
4. Входные данные
Входными данными являются действия играющего во время игры, то есть информация о нажатии клавиш управления курсором для управления героем и для выбора пункта меню, клавиши Esc для выхода из игры, клавиши Enter для выбора пункта меню, клавиши Space для сброса камней.
5. Выходные данные
Сообщение о победе после каждого пройденного уровня «Level complete», о проигрыше «Game over», либо сообщения, сопровождающие успешные или неуспешные действия игрока «Looser» — неудача, «2 hit combo» — при уничтожение сразу двух врагов, «Ough! 4 mans at once» — при уничтожении сразу четырех врагов, «Aaaaaaaaamazing!!!» -при уничтожении более четырех врагов.

Выходными данными, связанными с графикой, являются изменение положения человечка и врагов на экране монитора, а так же количество набранных очков игроком в этой игре, номер уровня.
6.Ошибки
При инициализации программы предусмотрена выдача сообщений при отсутствии
VGA совместимого видеоадаптера, ошибки инициализации графического режима.

3. СТРУКТУРНАЯ ДИАГРАММА

3.1 Описание назначения модулей.
S i e g e – основная программа, вызывающая на выполнение программные модули.
Модуль S i e g e S p r — модуль, содержащий игровые объекты (картинки).
Модуль V G A S p r – модуль для рисования спрайтов.
Модуль L o g o s c r e e n –заставка курсовой работы.
Модуль S i e g e L o g o – модуль, содержащий меню, инструкцию, предысторию.
Модуль B u t t o n s – модуль, позволяющий осуществлять нажатие и отпускание клавиши, информацию о состоянии клавиш в реальном времени и об отпущенных клавишах.
Модуль R e t r a c e – модуль,позволяющий осуществлять синхронизацию вывода в видеопамять.
Модуль V G A 1 3 H — модуль для работы с графикой.

ЗАКЛЮЧЕНИЕ

Таким образом, представляемая компьютерная игра относится к классу комбинаторных игр, поскольку может быть использована как в качестве развивающей внимание, реакцию, психомоторные навыки (способности) игры, так и для приятного времяпрепровождения и отдыха. При создании компьютерной игры мы старались сделать её по возможности красочнее, интереснее и увлекательнее.

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

СПИСОК ИСПОЛЬЗУЕМОЙ ЛИТЕРАТУРЫ
1. Игнатьева А.И. Компьютерные игры. (с. 3-10, 31-35) М. 1988.
2. Домашний компьютер — №4(с. 62-68),1999
3. Домашний компьютер — №12(с. 78-88),1999
1. Инфо–№2: Компьютерные игры в обучение (с.61-65) /Под ред. Марнуми Е.,

Когов Ю. 1990.
2. Лукашенко М.А. «Информатика в играх и задачах» (с.1-5) //Нач.шк.

/Приложение к газете «1 сентября» — 1994, №44
3. Инфо-№4: Компьютерная игра: учим или играем (64-67) /Под ред.
Марусева И.В. 1997.
7. Коубс Р. и Влейминк И. Интерфейс (36-40) 1991.
8. Ла Мот А. Секреты программирования игр (7-10) 1995.
9. Фридланд А.Я. Информатика. Толковый словарь основных терминов. (57-62)
М. 1998.
10. 350 игр для IBM PC, Дж. Дворак, «Пергамент» —
Санкт -Петербург, 1994 .
11. Turbo Pascal 7. 0, Фаронов В.В. /Изд. «Нолидж», 1999.

ПРИЛОЖЕНИЕ:
Program Siege;
Uses LogoScreen,

DOS, VGA13h, VGASpr, Retrace, Buttons,

SiegeLogo, SiegeS pr;
Type

EnemyType = record

X,Y,D,S,A:Integer;

Falling:Boolean;

Free:Boolean; end;
Const

MaxEnemies = 50;

ComboStr:Array [0..5] of String[20] =

(‘Looser!!!’,

»,

‘2 hit combo’,

‘Eat this!’,

‘Ough! 4 mans at once’,

‘Aaaaaaaaamazing!!!’);
Var

ManX,StoneY,StoneX,EnemyDelay,EnemyLimit:Integer;

Enemies:Array [1..MaxEnemies] of EnemyType;

Score,Level,Kills,Combo:Word;

Timer:Longint;

GameOver:Boolean;
{==================================================================}
Const ca:Word = 0; cc:String[20] = »;
Procedure ComboString(s:String); begin if s» then begin cc:=s; ca:=10; end; if ca>0 then begin

DrawString(Base2,160-Byte(cc[0])*4,90,cc);

Dec(ca); end; end;
Procedure NextLevel; forward;
{==================================================================}
Procedure InitEnemies;
Var i:Byte; begin for i:=1 to MaxEnemies do Enemies[i].Free:=true; end;
Procedure DrawEnemies;
Var i:Byte; begin for i:=1 to MaxEnemies do

With Enemies[i] do if not Free then

DrawTSpr(Base2,X,Y,EnemyHgt,EnemyWdt,@EnemySpr[A]); end;
Procedure MoveEnemies;
Var i:Byte; begin for i:=1 to MaxEnemies do

With Enemies[i] do if not Free then begin if Falling then begin

Y:=Y+10; if Y>199 then begin

Free:=true; if Kills=(Level+1)*20 then NextLevel; end; if D=0 then begin

Inc(A); if A>2 then A:=1;

D:=2; end else Dec(D); end else if D=0 then begin

Y:=Y-5; if Y2 then A:=1;

D:=S; end else Dec(D); end else if (EnemyLimit>0) and (EnemyDelay=0) then begin

X:=Random(38)*8;

Y:=200;

D:=0;

S:=(10-Level);

A:=1;

EnemyDelay:=(13-Level)*2+1;

Falling:=false;

Free:=false;

Dec(EnemyLimit); end;

Dec(EnemyDelay); end;
{==================================================================}
Procedure DrawScreen;
Var x,y:Integer; s:String[80]; tmp:String[6]; begin

Bar(Base2,0,0,319,9,8);

FillBase(Base2,3200,9600,$03030303); for y:=0 to 15 do for x:=0 to 31 do

DrawOSpr(Base2,x*10,40+y*10,BrickHgt,BrickWdt,@BrickSpr); s:=’ю ~SIEGE~ ю Level:’;

Str(Level,tmp);

While Byte(tmp[0])X) and (StoneXY) and (StoneY0 then Dec(ManX); if Key[keyRight] then if ManX=10) or GameOver; if GameOver then GameOverProc; end;
Procedure Done; begin

DoneButtons;

SetTextMode;

DoneVirtualPage; end;
{==================================================================}
Var choice:Byte; begin

Init;

Repeat choice:=Logo;

Case choice of

1:Game;

2:Info;

3:Story; end;

Until choice=4;

Done; end.

UNIT Buttons;
INTERFACE
Uses DOS;
Const keyESC = 1; keyF1 = 59; keyF2 = 60; keyF3 = 61; keyF4 = 62; keyF5 = 63; keyF6 = 64; keyF7 = 65; keyF8 = 66; keyF9 = 67; keyF10 = 68; keyF11 = 87; keyF12 = 88; keyScrollLock = 70; keyTilde = 41; key1 = 2; key2 = 3; key3 = 4; key4 = 5; key5 = 6; key6 = 7; key7 = 8; key8 = 9; key9 = 10; key0 = 11; keyUnderline = 12; keyEquality = 13; keyBackspace = 14; keyTab = 15; keyQ = 16; keyW = 17; keyE = 18; keyR = 19; keyT = 20; keyY = 21; keyU = 22; keyI = 23; keyO = 24; keyP = 25; keyIndex = 26; keyBackIndex = 27; keyEnter = 28; keyCapsLock = 58; keyA = 30; keyS = 31; keyD = 32; keyF = 33; keyG = 34; keyH = 35; keyJ = 36; keyK = 37; keyL = 38; keyDoublePeriod = 39; keyApostroph = 40; keyLShift = 42; keyBackSlash = 43; keyZ = 44; keyX = 45; keyC = 46; keyV = 47; keyB = 48; keyN = 49; keyM = 50; keyComma = 51; keyPeriod = 52; keySlash = 53; keyRShift = 54; keyCtrl = 29; keyAlt = 56; keySpace = 57; keyNumLock = 69; keyMultiply = 55; keyMinus = 74; keyPlus = 78; keyDelete = 83; keyHome = 71; keyUp = 72; keyPgUp = 73; keyLeft = 75; keyFive = 76; keyRight = 77; keyEnd = 79; keyDown = 80; keyPgDn = 81; keyInsert = 82;

KeyPressed:Boolean = FALSE;
Var

Key :Array [1..128] of Boolean;

WasPressed:Array [1..128] of Boolean;
Const

CheckWarmReboot:Boolean = TRUE;

WarmRebootFlag :Boolean = FALSE;
Procedure InitButtons;
Procedure DoneButtons;
Function ButtonsInited:Boolean;
Function IsKeypressed:Boolean;
Function Pressed(Index:Byte):Boolean;
Procedure ClearKeys;
IMPLEMENTATION
Const

Init:Boolean=FALSE;
Var

OldKbdHandler:Pointer;
Procedure Int9; INTERRUPT;
Var

ScanCode,Tmp:Byte; begin

ScanCode:=Port[$60]; if ScanCode and 128=0 then begin

Key[ScanCode]:=TRUE;

KeyPressed:=TRUE; end else begin

ScanCode:=ScanCode xor 128;

Key[ScanCode]:=FALSE;

WasPressed[ScanCode]:=TRUE;

KeyPressed:=FALSE; end; if CheckWarmReboot and (ScanCode=keyDelete) then begin

Tmp:=Mem[Seg0040:$0017]; if Tmp and 12=12 then begin

Tmp:=Tmp xor 21;

WarmRebootFlag:=TRUE; end;

Mem[Seg0040:$0017]:=Tmp; end; asm in al,61h or al,82h out 61h,al and al,7Fh out 61h,al mov al,20h out 20h,al end;

end;
Procedure InitButtons; begin if not Init then begin

GetIntVec($9,OldKbdHandler);

SetIntVec($9,@Int9);

FillChar(Key,SizeOf(Key),FALSE);

FillChar(WasPressed,SizeOf(WasPressed),FALSE);

CheckWarmReboot:=TRUE;

WarmRebootFlag:=FALSE;

Init:=TRUE; end; end;
Procedure DoneButtons; begin if Init then begin

SetIntVec($9,OldKbdHandler);

WarmRebootFlag:=FALSE;

Init:=FALSE; end; end;
Function ButtonsInited; begin

ButtonsInited:=Init; end;
Function IsKeypressed;
Var i:Byte; f:Boolean; begin f:=false; i:=1;

While (i’);

Old:=Res; end; if Pressed(keyUp) then begin

Res:=Res-1; if Res4 then Res:=1; end;

Until Key[keyEnter];

Logo:=Res; end;
Procedure Center(y:Integer;Const s:String); begin

DrawString(Base1,160-(Length(s)*8 div 2),y,s); end;
Procedure Info; begin

ClearBase(Base1);

Center(2,’Instructions’);

Center(20,’Arrows — moving Hero’);

Center(30,’Space — throw stone’);

Center(40,’Esc — exit the game’);

Center(190,’Press any key’);

ClearKeys;

Repeat Until IsKeypressed; end;
Procedure Story; begin
ClearBase(Base1);
Center(2,’Предыстория’);
DrawString(Base1,1,20,’Много лет назад на Землю упал метеорит.’);
DrawString(Base1,1,30,’При исследовании в лаборатории ученые ‘);
DrawString(Base1,1,40,’обнаружили в нем биологическое вещес- ‘);
DrawString(Base1,1,50,’тво внеземного происхождения. Поняв всю’);
DrawString(Base1,1,60,’опасность этого вируса, они попытались ‘);
DrawString(Base1,1,70,’нейтрализовать его.Но вирус стал быстро’);
DrawString(Base1,1,80,’распространяться и заразил всех участни ‘);
DrawString(Base1,1,90,’ков исследования. Выйдя за стены лабора-‘);
DrawString(Base1,1,100,’ тории он стал зарожать людей.Зараженные’);
DrawString(Base1,1,110,’вирусом внешне не отличались от обычных’);
DrawString(Base1,1,120,’людей, но подчинялись внеземному разуму.’);
DrawString(Base1,1,130,’Их задачей было:уничтожить оставшееся ‘);
DrawString(Base1,1,140,’население.Тогда люди стали объединять- ‘);
DrawString(Base1,1,150,’ся,чтобы защитить себя. Они устроили ‘);
DrawString(Base1,1,160,’засаду в крепости. Но агрессивных «лик-‘);
DrawString(Base1,1,170,’видаторов ничто не могло остановить…..’);
ClearKeys;

Repeat Until IsKeypressed; end;
END.

UNIT SiegeSpr;
INTERFACE
Const

BrickHgt = 10;

BrickWdt = 10;

BrickSpr:Array [1..BrickHgt,1..BrickWdt] of Byte =

((7,7,7,7,7,7,7,7,7,7),

(4,4,4,4,4,4,4,4,4,7),

(4,4,4,4,4,4,4,4,4,7),

(4,4,4,4,4,4,4,4,4,7),

(4,4,4,4,4,4,4,4,4,7),

(7,7,7,7,7,7,7,7,7,7),

(4,4,4,4,7,4,4,4,4,4),

(4,4,4,4,7,4,4,4,4,4),

(4,4,4,4,7,4,4,4,4,4),

(4,4,4,4,7,4,4,4,4,4));
Const

StoneHgt = 8;

StoneWdt = 8;

StoneSpr:Array [1..StoneHgt,1..StoneWdt] of Byte =

((0,0,8,8,8,8,0,0),

(0,8,7,7,8,8,8,0),

(8,7,8,8,8,8,8,8),

(8,7,8,8,8,8,8,8),

(8,8,8,8,8,8,8,8),

(8,8,8,8,8,8,8,8),

(0,8,8,8,8,8,8,0),

(0,0,8,8,8,8,0,0));
Const

ManHgt = 20;

ManWdt = 16;

ManSpr:Array [1..2,1..ManHgt,1..ManWdt] of Byte =

(((00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,00,00,00,00,00, 7, 7, 7, 7,00,00,00,00,00,00),

(00,00,00,00,00, 7, 7, 7, 7, 7, 7,00,00,00,00,00),

(00,00,00,00,00, 7,15,15,15,15, 7,00,00,00,00,00),

(00,00,00,00,00,15, 3, 1, 1, 3,15,00,00,00,00,00),

(00,00,00,00,00,15,15,15,15,15,15,00,00,00,00,00),

(00,00,00,00,00,15,15, 8, 8,15,15,00,00,00,00,00),

(00,00,00,00,00,15,15,13,13,15,15,00,00,00,00,00),

(00,00,00,00,00,00,15,15,15,15,00,00,00,00,00,00),

(00,00,00,00,12,12,15,15,15,15,12,12,00,00,00,00),

(00,12,12,12,12,12,12,14,14,12,12,12,12,12,12,00),

(12,12,12,12,12,12,12,14,14,12,12,12,12,12,12,12),

(12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12),

(12,12, 8,12,12,12,12,12,12,12,12,12,12, 8,12,12),

(12,12, 8,12,12,12,12,12, 8,12,12,12,12, 8,12,12),

(12,12, 8,12,12,12,12,12,12,12,12,12,12, 8,12,12),

(12,12, 8,12,12,12,12,12, 8,12,12,12,12, 8,12,12)),

((00,00,00,15,00,00,00,00,00,00,00,00,15,00,00,00),

(00,00,00,15,00,00,00,00,00,00,00,00,15,00,00,00),

(00,00,12,12,00,00,00,00,00,00,00,00,12,12,00,00),

(00,00,12,12,00,00,00,00,00,00,00,00,12,12,00,00),

(00,00,12,12,00,00, 7, 7, 7, 7,00,00,12,12,00,00),

(00,00,12,12,00, 7, 7, 7, 7, 7, 7,00,12,12,00,00),

(00,12,12,00,00, 7,15,15,15,15, 7,00,00,12,12,00),

(00,12,12,00,00,15, 3, 1, 1, 3,15,00,00,12,12,00),

(00,12,12,00,00,15,15,15,15,15,15,00,00,12,12,00),

(00,12,12,00,00,15,15, 8, 8,15,15,00,00,12,12,00),

(00,12,12,00,00,15,15,13,13,15,15,00,00,12,12,00),

(00,12,12,12,00,00,15,15,15,15,00,00,12,12,12,00),

(00,00,12,12,12,12,15,15,15,15,12,12,12,12,00,00),

(00,00,12,12,12,12,12,14,14,12,12,12,12,12,00,00),

(00,00,12,12,12,12,12,14,14,12,12,12,12,12,00,00),

(00,00,12,12,12,12,12,12,12,12,12,12,12,12,00,00),

(00,00,00,12,12,12,12,12,12,12,12,12,12,00,00,00),

(00,00,00,12,12,12,12,12, 8,12,12,12,12,00,00,00),

(00,00,00,12,12,12,12,12,12,12,12,12,12,00,00,00),

(00,00,00,12,12,12,12,12, 8,12,12,12,12,00,00,00)));
Const

EnemyHgt = 42;

EnemyWdt = 16;

EnemySpr:Array [1..2,1..EnemyHgt,1..EnemyWdt] of Byte =

(((00,00,00,00,00,00,00,00,00,00,00,00,00,00,15,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,00,15,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,10,10,00),

(00,00,00,00,00,00,00,00,00,00,00,00,00,10,10,00),

(00,00,00,00,00,00, 7, 7, 7, 7,00,00,00,10,10,00),

(00,00,00,00,00, 7, 7, 7, 7, 7, 7,00,00,10,10,00),

(00,00,00,00,00, 7, 7, 7, 7, 7, 7,00,00,10,10,00),

(00,00,00,00,00, 7, 7, 7, 7, 7, 7,00,00,10,10,00),

(00,00,00,00,00, 7, 7, 7, 7, 7, 7,00,00,10,10,00),

(00,00,00,00,00,15, 7, 7, 7, 7,15,00,00,10,10,00),

(00,00,00,00,00,15, 7, 7, 7, 7,15,00,00,10,10,00),

(00,00,00,00,00,00,15,15,15,15,00,00,10,10,10,00),

(00,00,00,00,10,10,15,15,15,15,10,10,10,10,00,00),

(00,10,10,10,10,10,10,10,10,10,10,10,10,10,00,00),

(10,10,10,10,10,10,10,10,10,10,10,10,10,10,00,00),

(10,10,10,10,10,10,10,10,10,10,10,10,10,10,00,00),

(10,10,00,10,10,10,10,10,10,10,10,10,10,00,00,00),

(10,10,00,10,10,10,10,10,10,10,10,10,10,00,00,00),

(10,10,00,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,10,10,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,10,10,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,10,10,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,00,00,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,00,00, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,00,00,00),

(00,00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00,00),

(00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00,00),

(00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00,00),

(00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00,00),

(00, 8, 8, 8, 8,00,00,00,00, 8, 8, 8, 8,00,00,00),

( 8, 8, 8, 8, 8,00,00,00,00, 8, 8, 8, 8, 8,00,00),

( 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00,00),

( 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00,00),

( 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00,00),

(00, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00,00),

(00, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00,00),

(00,00, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00,00,00,00,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00,00,00,00,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00,00,00,00,00,00,00,00,00,00, 8, 8, 8, 8,00),

(00,00,00,00,00,00,00,00,00,00,00, 8, 8, 8, 8,00)),

((00,15,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,15,00,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,10,10,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,10,10,00,00,00,00,00,00,00,00,00,00,00,00,00),

(00,10,10,00,00,00, 7, 7, 7, 7,00,00,00,00,00,00),

(00,10,10,00,00, 7, 7, 7, 7, 7, 7,00,00,00,00,00),

(00,10,10,00,00, 7, 7, 7, 7, 7, 7,00,00,00,00,00),

(00,10,10,00,00, 7, 7, 7, 7, 7, 7,00,00,00,00,00),

(00,10,10,00,00, 7, 7, 7, 7, 7, 7,00,00,00,00,00),

(00,10,10,00,00,15, 7, 7, 7, 7,15,00,00,00,00,00),

(00,10,10,00,00,15, 7, 7, 7, 7,15,00,00,00,00,00),

(00,10,10,10,00,00,15,15,15,15,00,00,00,00,00,00),

(00,00,10,10,10,10,15,15,15,15,10,10,10,10,00,00),

(00,00,10,10,10,10,10,10,10,10,10,10,10,10,10,00),

(00,00,10,10,10,10,10,10,10,10,10,10,10,10,10,10),

(00,00,10,10,10,10,10,10,10,10,10,10,10,10,10,10),

(00,00,00,10,10,10,10,10,10,10,10,10,10,00,10,10),

(00,00,00,10,10,10,10,10,10,10,10,10,10,00,10,10),

(00,00,00,10,10,10,10,10,10,10,10,10,10,00,10,10),

(00,00,00,10,10,10,10,10,10,10,10,10,10,10,10,00),

(00,00,00,10,10,10,10,10,10,10,10,10,10,10,10,00),

(00,00,00,10,10,10,10,10,10,10,10,10,10,10,10,00),

(00,00,00,10,10,10,10,10,10,10,10,10,10,00,00,00),

(00,00,00, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,00,00,00),

(00,00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00,00),

(00,00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00),

(00,00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00,00),

(00,00,00, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,00),

(00,00, 8, 8, 8, 8, 8,00,00,00,00, 8, 8, 8, 8,00),

(00,00, 8, 8, 8, 8, 8,00,00,00,00, 8, 8, 8, 8, 8),

(00,00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8),

(00,00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8),

(00,00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8, 8),

(00,00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8,00),

(00,00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00, 8, 8, 8,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00,00,00,00,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00,00,00,00,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00,00,00,00,00,00),

(00, 8, 8, 8, 8,00,00,00,00,00,00,00,00,00,00,00)));
IMPLEMENTATION
END.

UNIT VGA13h;
INTERFACE
Type

PScreen = ^TScreen;

TScreen = Array [0..199,0..319] of Byte;
Const

ScreenHeight = 200;

ScreenWidth = 320;

GetMaxY = ScreenHeight-1;

GetMaxX = ScreenWidth-1;

MidX = GetMaxX div 2;

MidY = GetMaxY div 2;

PageSize = ScreenHeight*ScreenWidth;

QuarterSize = PageSize div 4;

VideoSegment:Word = 0;

Base1:Word = 0;

Base2:Word = 0;

Page1:PScreen = NIL;

Page2:PScreen = NIL;
Function DetectVGA:Boolean;
Procedure SetGraphMode;
Procedure SetTextMode;
Procedure MakePixelSquare;
Procedure CopyBase(Source,Destin:Word);
Procedure ClearBase(Base:Word);
Procedure FillBase(Base,Ofs,Count:Word;Color:Longint);
Procedure MoveBase(Source,Destin,Count:Word);
Procedure TileBase(Base,Ofs,Count:Word;Tile:Pointer;Len:Word);
Procedure PutPixel(Base:Word;x,y:Integer;Color:Byte);
Function GetPixel(Base:Word;x,y:Integer):Byte;
Procedure Line(Base:Word;x1,y1,x2,y2:Integer;Color:Byte);
Procedure VLine(Base:Word;x,y1,y2:Integer;Color:Byte);
Procedure HLine(Base:Word;y,x1,x2:Integer;Color:Byte);
Procedure Bar(Base:Word;x1,y1,x2,y2:Integer;Color:Byte);
Procedure Polygon(Base:Word;x1,y1,x2,y2,x3,y3,x4,y4:Integer;c:Byte);
Function InitVirtualPage:Boolean;
Procedure DoneVirtualPage;
IMPLEMENTATION
Var

VirtualPage:Pointer;

{$L VGA13H.OBJ}
Function DetectVGA; external;
Procedure SetGraphMode; external;
Procedure SetTextMode; external;
Procedure MakePixelSquare; external;
Procedure CopyBase; external;
Procedure ClearBase; external;
Procedure FillBase; external;
Procedure MoveBase; external;
Procedure TileBase; external;
Procedure PutPixel; external;
Function GetPixel; external;
Procedure HLine; external;
Procedure VLine; external;

Procedure Polygon;
Var xpos:array [0..199,0..1] of Word; mny,mxy,y:Integer; i:Word; s1,s2,s3,s4:Shortint; begin mny:=y1; if y2mxy then mxy:=y4; s1:=byte(y1

Альтернативные Интерфейсы

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

Интерфейс

Рассмотрим такое написание класса slist для однократно связанного списка, с помощью которого можно создавать как однородные, так и неоднородные списки объектов тех типов, которые еще должны быть определены. Сначала мы определим тип ent:

typedef void* ent;

Точная сущность типа ent несущественна, но нужно, чтобы в нем мог храниться указатель. Тогда мы определим тип slink:

class slink {

friend class slist;

friend class slist_iterator;

  slink* next;

  ent e;

  slink(ent a, slink* p) { e=a; next=p;}

};

В одном звене может храниться один ent, и с помощью него реализуется класс slist:

class slist {

friend class slist_iterator;

  slink* last;        // last->next — голова списка

public:

  int insert(ent a);  // добавить в голову списка

  int append(ent a);  // добавить в хвост списка

  ent get();          // вернуться и убрать голову списка

  void clear();       // убрать все звенья

  slist()      { last=0; }

  slist(ent a) { last=new slink(a,0); last->next=last; }

  ~slist()     { clear(); }

};

Хотя список очевидным образом реализуется как связанный список, реализацию можно изменить так, чтобы использовался вектор из ent»ов, не повлияв при этом на пользователей. То есть, применение slink»ов никак не видно в описаниях открытых функций slist»ов, а видно только в закрытой части и определениях функций.

Реализация

Реализующие slist функции в основном просты. Единственная настоящая сложность — что делать в случае ошибки, если, например, пользователь попытается get() что-нибудь из пустого списка. Здесь приводятся определения членов slist. Обратите внимание, как хранение указателя на последний элемент кругового списка дает возможность просто реализовать оба действия append() и insert():

int slist::insert(ent a)

{

if (last)

last->next = new slink(a,last->next);

else {

last = new slink(a,0);

last->next = last;

}

return 0;

}

int slist::append(ent a)

{

if (last)

last = last->next = new slink(a,last->next);

else {

last = new slink(a,0);

last->next = last;

}

return 0;

}

ent slist::get()

{

if (last == 0) slist_handler(«get fromempty list»);

// взять из пустого списка

slink* f = last->next;

ent r f->e;

if (f == last)

last = 0;

else

last->next = f->next;

delete f;

return f;

}

Обратите внимание, как вызывается slist_handler. Этот указатель на имя функции используется точно так же, как если бы он был именем функции. Это является краткой формой более явной записи вызова:

(*slist_handler)(«get fromempty list»);

И slist::clear(), наконец, удаляет из списка все элементы:

void slist::clear()

{

slink* l = last;

if (l == 0) return;

do {

slink* ll = l;

l = l->next;

delete ll;

} while (l!=last);

}

Класс slist не обеспечивает способа заглянуть в список, но только средства для вставления и удаления элементов. Однако оба класса, и slist, и slink, описывают класс slist_iterator как друга, поэтому мы можем описать подходящий итератор. Вот один, написанный в духе этого пункта:

class slist_iterator {

slink* ce;

slist* cs;

public:

slist_iterator(slist& s) { cs = &s ce = cs->last; }

ent operator()() {

// для индикации конца итерации возвращает 0

// для всех типов не идеален, хорош для указателей

ent ret = ce ? (ce=ce->next)->e : 0;

if (ce == cs->last) ce= 0;

return ret;

}

};

Как Этим Пользоваться

Фактически класс slist в написанном виде бесполезен. В конечном счете, зачем можно использовать список указателей void*? Штука в том, чтобы вывести класс из slist и получить список тех объектов, которые представляют интерес в конкретной программе. Представим компилятор языка вроде C++. В нем широко будут использоваться списки имен; имя — это нечто вроде

struct name {

char* string;

// …

};

В список будут помещаться указатели на имена, а не сами объекты имена. Это позволяет использовать небольшое информационное поле e slist»а, и дает возможность имени находиться одновременно более чем в одном списке. Вот определение класса nlist, который очень просто выводится из класса slist:

#include «slist.h»

#include «name.h»

struct nlist : slist {

void insert(name* a) { slist::insert(a); }

void append(name* a) { slist::append(a); }

name* get() {}

nlist(name* a) : (a) {}

};

Функции нового класса или наследуются от slist непосредственно, или ничего не делают кроме преобразования типа. Класс nlist — это ничто иное, как альтернативный интерфейс класса slist. Так как на самом деле тип ent есть void*, нет необходимости явно преобразовывать указатели name*, которые используются в качестве фактических параметров .

Списки имен можно использовать в классе, который представляет определение класса:

struct classdef {

nlist friends;

nlist constructors;

nlist destructors;

nlist members;

nlist operators;

nlist virtuals;

// …

void add_name(name*);

classdef();

~classdef();

};

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

void classdef::add_name(name* n)

{

if (n->is_friend()) {

if (find(&friends,n))

error(«friend redeclared»);

else if (find(&members,n))

error(«friend redeclared as member»);

else

friends.append(n);

}

if (n->is_operator()) operators.append(n);

// …

}

где is_iterator() и is_friend() являются функциями членами класса name. Фукнцию find() можно написать так:

int find(nlist* ll, name* n)

{

slist_iterator ff(*(slist*)ll);

ent p;

while ( p=ff() ) if (p==n) return 1;

return 0;

}

Здесь применяется явное преобразование типа, чтобы применить slist_iterator к nlist. Более хорошее решение, — сделать итератор для nlist»ов. Печатать nlist может, например, такая функция:

void print_list(nlist* ll, char* list_name)

{

slist_iterator count(*(slist*)ll);

name* p;

int n = 0;

while ( count() ) n++;

cout << list_name << «n» << n << «membersn»;

slist_iterator print(*(slist*)ll);

while ( p=(name*)print() ) cout << p->string << «n»;

}

Обработка Ошибок

Есть четыре подхода к проблеме, что же делать, когда во время выполнения общецелевое средство вроде slist сталкивается с ошибкой (в C++ нет никаких специальных средств языка для обработке ошибок):

Возвращать недопустимое значение и позволить пользователю его проверять;

Возвращать дополнительное значение состояния и разрешить пользователю проверять его;

Вызывать функцию ошибок, заданную как часть класса slist; или

Вызывать функцию ошибок, которую предположительно предоставляет пользователь.

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

Первый подход, возвращать недопустимое значение, неосуществим. Нет совершенно никакого способа узнать, что некоторое конкретное значение будет недопустимым во всех применениях slist.

Второй подход, возвращать значение состояния, можно использовать в некоторых классах (один из вариантов этого плана применяется в стандартных потоках ввода/вывода istream и ostream). Здесь, однако, имеется серьезная проблема, вдруг пользователь не позаботится проверить значение состояния, если средство не слишком часто подводит. Кроме того, средство может использоваться в сотнях или даже тысячах мест программы. Проверка значения в каждом месте сильно затруднит чтение программы.

Третьему подходу, предоставлять функцию ошибок, недостает гибкости. Тот, кто реализует общецелевое средство, не может узнать, как пользователи захотят, чтобы обрабатывались ошибки. Например, пользователь может предпочитать сообщения на датском или венгерском.

Четвертый подход, позволить пользователю задавать функцию ошибок, имеет некоторую привлекательность при условии, что разработчик предоставляет класс в виде библиотеки (#4.5), в которой содержатся стандартные функции обработки ошибок. Решения 3 и 4 можно сделать более гибкими (и по сути эквивалентными), задав указатель на функцию, а не саму функцию. Это позволит разработчику такого средства, как slist, предоставить функцию ошибок, действующую по умолчанию, и при этом программистам, которые будут использовать списки, будет легко задать свои собственные функции ошибок, если нужно, и там, где нужно.

Например:

typedef void (*PFC)(char*); // указатель на тип функция

extern PFC slist_handler;

extern PFC set_slist_handler(PFC);

Функция set_slist_hanlder() позволяет пользователю заменить стандартную функцию. Общепринятая реализация предоставляет действующую по умолчанию функцию обработки ошибок, которая сначала пишет сообщение об ошибке в cerr, после чего завершает программу с помощью exit():

#include «slist.h»

#include

void default_error(char* s)

{

cerr << s << «n»;

exit(1);

}

Она описывает также указатель на функцию ошибок и, для удобства записи, функцию для ее установки:

PFC slist_handler = default_error;

PFC set_slist_handler(PFC handler);

{

PFC rr = slist_handler;

slist_handler = handler;

return rr;

}

Обратите внимание, как set_slist_hanlder() возвращает предыдущий slist_hanlder(). Это делает удобным установку и переустановку обработчиков ошибок на манер стека. Это может быть в основном полезным в больших программах, в которых slist может использоваться в нескольких разных ситуациях, в каждой из которых могут, таким образом, задаваться свои собственные подпрограммы обработки ошибок.

Например:

{

PFC old = set_slist_handler(my_handler);

// код, в котором в случае ошибок в slist

// будет использоваться мой обработчик my_handler

set_slist_handler(old); // восстановление

}

Чтобы сделать управление более изящным, slist_hanlder мог бы быть сделан членом класса slist, что позволило бы различным спискам иметь одновременно разные обработчики.

Обобщенные Классы

Очевидно, можно было бы определить списки других типов (classdef*, int, char* и т.д.) точно так же, как был определен класс nlist: простым выводом из класса slist. Процесс определения таких новых типов утомителен (и потому чреват ошибками), но с помощью макросов его можно «механизировать». К сожалению, если пользоваться стандартным C препроцессором, это тоже может оказаться тягостным. Однако полученными в результате макросами пользоваться довольно просто.

Вот пример того, как обобщенный (generic) класс slist, названный gslist, может быть задан как макрос. Сначала для написания такого рода макросов включаются некоторые инструменты из :

.html#include «slist.h»

#ifndef GENERICH

#include

#endif

Обратите внимание на использование #ifndef для того, чтобы гарантировать, что в одной компиляции не будет включен дважды. GENERICH определен в .

После этого с помощью name2(), макроса из для конкатенации имен, определяются имена новых обобщенных классов:

#define gslist(type) name2(type,gslist)

#define gslist_iterator(type) name2(type,gslist_iterator)

И, наконец, можно написать классы gslist(тип) и gslist_iterator(тип):

#define gslistdeclare(type)

struct gslist(type) : slist {

int insert(type a)

{ return slist::insert( ent(a) ); }

int append(type a)

{ return slist::append( ent(a) ); }

type get() { return type( slist::get() ); }

gslist(type)() { }

gslist(type)(type a) : (ent(a)) { }

~gslist(type)() { clear(); }

};

struct gslist_iterator(type) : slist_iterator {

gslist_iterator(type)(gslist(type)& a)

: ( (slist&)s ) {}

type operator()()

{ return type( slist_iterator::operator()() ); }

}

на конце строк указывает , что следующая строка является частью определяемого макроса.

С помощью этого макроса список указателей на имя, аналогичный использованному раньше классу nlist, можно определить так:

#include «name.h»

typedef name* Pname;

declare(gslist,Pname); // описать класс gslist(Pname)

gslist(Pname) nl; // описать один gslist(Pname)

Макрос declare (описать) определен в . Он конкатенирует свои параметры и вызывает макрос с этим именем, в данном случае gslistdeclare, описанный выше. Параметр имя типа для declare должен быть простым именем. Используемый метод макроопределения не может обрабатывать имена типов вроде name*, поэтому применяется typedef.

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

Ограниченные Интерфейсы

Класс slist — довольно общего характера. Иногда подобная общность не требуется или даже нежелательна. Ограниченные виды списков, такие как стеки и очереди, даже более обычны, чем сам обобщенный список. Такие структуры данных можно задать, не описав базовый класс как открытый. Например, очередь целых можно определить так:

#include «slist.h»

class iqueue : slist {

//предполагается sizeof(int)<=sizeof(void*)

public:

void put(int a) { slist::append((void*)a); }

int det() { return int(slist::get()); }

iqueue() {}

};

При таком выводе осуществляются два логически разделенных действия: понятие списка ограничивается понятием очереди (сводится к нему), и задается тип int, чтобы свести понятие очереди к типу данных очередь целых, iqueue. Эти два действия можно выполнять и раздельно. Здесь первая часть — это список, ограниченный так, что он может использоваться только как стек:

#include «slist.h»

class stack : slist {

public:

slist::insert;

slist::get;

stack() {}

stack(ent a) : (a) {}

};

который потом используется для создания типа «стек указателей на символы»:

#include «stack.h»

class cp : stack {

public:

void push(char* a) { slist::insert(a); }

char* pop() { return (char*)slist::get(); }

nlist() {}

};

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://www.realcoding.net

МИНИСТЕРСТВО ОБЩЕГО И ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ

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

Кафедра вычислительной техники

КУРСОВАЯ РАБОТА

По курсу «Технология программирования»

Тема: “Игровая программа “TETRIS”

Выполнил: студент гр. ВЗ-107 Афонин В.Ю.

Проверил: к. т. н., доцент Цехоня Вячеслав

Иванович

Таганрог — 2000

Задание.
Написать на языке PASCAL и отладить в интерактивном режиме игровую программу TETRIS.
Основное внимание необходимо уделить процессу нисходящего поуровневого проектирования алгоритма.

Оглавление.
1. Техническое задание
…………………………………………………………………. стр. 3.
2. Практическая часть .
2.1. Пояснительная записка (технический проект)
……………..….……….. стр. 4.
2.2. Руководство (системного) программиста
………………………….……… стр. 7.
2.3. Руководство оператора (пользователя)
………………………….…………. стр. 8.
2.4. Описание программы
……………………………………………………….…….. стр.
9.
3. Заключение
………………………………………………………………….
…..……….. стр. 10.
4. Литература
………………………………………………………………….
…………….. стр. 11.
5. Приложения.
5.1. Текст программы
……………………………………………………………………
.. стр. 12.

Техническое задание (ГОСТ 19.201-78).
1.Введение.
Наименование программы — «TETRIS». Применение программы — в области игровых программ.
2. Основание для разработки.
Выполнение курсовой работы.
3. Назначение разработки.
Данная программа является игровой, она применяется для развлечения пользователей, совершенствования их координации движения и логического мышления.
4. Требования к программе.
4.1. Требования к функциональным характеристикам.
В состав программы входят функции отображения на экране двужущихся фигурок, параллельного переноса их вправо и влево, поворота вокруг собственной оси, быстрого падения на дно короба и ряд вспомогательных функций (контроль наложения фигур, отображение элементов фигур и т.д.).
Входные данные — коды нажимаемых клавиш.
Выходные данные — графическая информация, выводимая на экран.
В работе программы временные характеристики несущественны.
4.2. Требования к надежности.
Надежное функционирование программы обеспечивается проверкой наложения при перемещении фигур и ограничением, накладываемым на набор входных данных
(коды нажатых клавиш игнорируются, если эти клавиши не являются управляющими в игре).
4.3. Требования к составу и параметрам технических средств ЭВМ, внешние устройства, их характеристики.
Для функционирования программы требуется персональная ЭВМ с процессором
8086/8088, от 640 килобайт оперативной памяти, видеоадаптер VGA/EGA и соответствующий монитор. Прочие внешние устройства для работы программы не требуются.
4.4. Требования к информационной и программной совместимости ОС, система программирования, используемые программные средства, методы решения, информационные структуры и т.п.
Для функционирования программы требуется ОС MS-DOS версии 3.30 или выше, от
32 килобайт свободной оперативной памяти. Программа разработана в интегрирированной среде Turbo Pascal версии 7.0.
4.5. Специальные требования.
Специальные требования отсутствуют.
5. Требования к программной документации.
Требования к программной документации отсутствуют.
6. Технико-экономические показатели. Ориентировочная экономическая эффективность, преимущества по сравнению с аналогами.
Преимуществом по сравнению с аналогом является постоянное увеличение скорости игры.

Практическая часть.

Пояснительная записка (ГОСТ 19.404-79)
1. Введение
Наименование программы — «TETRIS», основание разработки — выполнение курсовой работы.
2. Назначение и область применения программы.
Назначение программы — развлечение играющих, совершенствование их координации и логического мышления. Программа может применяться в качестве игровой на разных типах персональных компьютеров.
3. Технические характеристики.
3.1. Постановка задачи на разработку, описание методов решения.
Разработать алгоритм программы, осуществляющей передвижение фигур по экрану сверху вниз, координацию их местоположения в соответствии с действиями играющего.
Фигуры состоят из квадратов одинакового размера, набор фигур конечен, последовательность появления фигур должна быть случайной, причем появления фигур должны быть равновероятными. Игрок должен укладывать фигуры на дно ящика с наибольшей плотностью (количество незаполненных квадратов должно быть минимальным). При этом если слой, полностью заполненный квадратами, должен автоматически изыматься из ящика. Квадраты фигур не должны налагаться друг на друга. Поворот фугры вокруг своей оси должен осуществляться таким образом, чтобы не были задеты другие фигуры, стенки, дно ящика.
3.2. Описание алгоритма и/или функционирования программы
[pic]

3.3. Описание и обоснование выбора метода организации данных.
|Данные |Метод организации |
|Фигура |Двумерный массив-наиболее |
| |естественное представление, |
| |например: |
| |[pic] |
|Ящик |Двумерный массив, элемент |
| |которого-целое число — |
| |соответствует свободной или |
| |занятой ячейке. |
|Каталог фигур |Массив из приведенных выше матриц.|
|Ширина, высота ящика,количество |Константы |
|цветов и фигур; флаги наложения, | |
|достижения дна ящика, свободной | |
|ячейки и др. | |

3.4. Описание и обоснование выбора состава технических и программных средств.
Для написания программы был выбран язык Паскаль. Отказ от библиотеки Turbo
Vision был продиктован невозможностью работы с этой библиотекой в графическом режиме.
4. Ожидаемые технико-экономические показатели.
Ожидаемая разработка будет отличаться низкими требованиями к аппаратной части ЭВМ.
5. Источники, используемые при разработке.
При разработке используется статья «Новый мотор для старой идеи» из журнала
«Монитор» № 3 за 1994 год.
Приложения отсутствуют.

Руководство (системного) программиста (ГОСТ 19.504-79).
1. Назначение и условие применения программы.
Назначение программы — развлечение играющих, совершенствование их координации и логического мышления. Программа может применяться в качестве игровой на разных типах персональных компьютеров и распространяется на условиях freeware.
2. Характристики программы.
Программа запускается под управлением операционной системы MS-DOS версии
3.30 и выше из каталога, в котором содержится драйвер видеоадаптера egavga.bgi. Для её работы требуется от 32 килобайтов свободной оперативной памяти, видеоадаптер EGA/VGA и процессор 8086/8088 и выше.
3. Обращение к программе.
Обращение к программе осуществляется командой tetris.
4. Входные и выходные данные.
Входные данные — коды нажатых в режиме реального времени клавиш. Выходные данные — графическая информация на дисплее.
5. Сообщения (сообщения системному программисту).
Для нормальной (без замедления) работы программы на ЭВМ AT 286 или ЭВМ
PC XT рекомендуется уменьшить значение, присваиваемое переменной speed, в 2-

3 раза. По аналогии рекомендуется увеличить это значение при использовании программы на ЭВМ AT 486 и PENTIUM. После этого программу рекомендуется перекомпилировать.
6. Структура программы.
Исходный текст программы хранится в 1-м файле: tetris.pas.
Компиляция в турбо-среде осуществляется с использованием файла tetris.pas.
7. Настройка программы.
Программа готова к работе, настройки не требует.
8. Проверка программы.
Проверка работоспособности программы осуществляется в следующих случаях:
— независание фигуры при падении;
— падение фигуры до дна ящика;
— невыход фигуры за границы ящика;
— сдвиг фигуры и поворот её на расстоянии от стенок;
— сдвиг фигуры вблизи стенки и поворот её (при этом не должно происходить наложение фигуры на границу ящика);
— неналожение фигуры при достижении лежащих на дне ящика других фигур;
— изъятие слоя, не содержащего пустых ячеек (все ячейки заполнены квадратами фигур);
— «оседание» слоев при изъятии слоя, не содержащего пустых ячеек;
— окончание игры при заполнении ящика или по команде игрока.
9. Дополнительные возможности.
Дополнительные возможности отсутствуют.
Приложения отсутствуют.

Руководство оператора (пользователя) (ГОСТ 19.505-79).
1. Назначение программы.
Назначение программы — развлечение играющих, совершенствование их координации и логического мышления.
2. Условия выполнения программы.
Программа запускается под управлением операционной системы MS-DOS версии
3.30 и выше из каталога, в котором содержится драйвер видеоадаптера egavga.bgi. Для её работы требуется от 32 килобайтов свободной оперативной памяти, видеоадаптер EGA/VGA и процессор 8086/8088 и выше.
3. Выполнение программы.
Запуск программы осуществляется командой tetris из каталога, содержащего файлы tetris.exe и egavga.bgi. При запуске появляется окно с названием программы, прекратить вывод которого можно нажатием на клавишу .
После этого на экране появляется ящик с падающими фигурами. Управление игрой осуществляется следующими клавишами:
|Название клавиши |Выполняемая функция |
|Стрелка вправо |Сдвиг фигуры вправо |
|Стрелка влево |Сдвиг фигуры влево |
|Стрелка вверх |Поворот фигуры вокруг собственной |
| |оси |
|Стрелка вниз |Падение фигуры до дна ящика |
|ESC |Окончание игры |

4. Сообщения оператору.
При работе прогрммы на машинах PC AT 286 или PC XT рекомендуется уменьшить значения, присваиваемые переменной speed в 2-3 раза для того, чтобы скорость падения фигур была приемлемой для игры.
Приложения отсутствуют.

Описание программы (ГОСТ 19.402-78)
1. Общие сведения.
Программа называется «TETRIS», является классической версией отечественной игры ТЕТРИС. Программа написана на языке Pascal в интегрированной среде
Turbo Pascal v7.0. Для её выполнения требуется компилятор с этого языка и
ОС. Техническая документация написана с использованием программных продуктов Microsoft Word 97 и Meta Design 4.0.
2. Функциональное назначение.
Данная программа является игровой, она применяется для развлечения пользователей, совершенствования их координации движения и логического мышления.
3. Описание логической структуры.
Описание логической структуры приведено на схемах, находящихся в приложении
( № 3.1a)
4. Используемые технические средства.
Программа была написана и откомпилирована на ЭВМ Pentium-233
MMX/32/2.1/SVGA .28, оснащенной устройством печати HP LJ-6L.
5. Вызов и загрузка.
Программа хранится в файлe tetris.pas; программа вызывается на выполнение командой tetris.
6. Входные данные.
1) клавиши: «RIGHT», «LEFT», «UP», «DOWN» или «ESC» — вводимые в процессе игры в режиме реального времени. Организованы в виде символьных переменных.
7. Выходные данные.
Информация, выводимая на экран в графическом режиме: рисунок ящика, падающие и лежащие на дне фигуры. Организованы в виде двумерных массивов.
Приложение содержит листинг программы на языке Turbo Pascal.
Выводы по задаче.
В результате использованггия бета-версии программы не было получено жалоб об отклонениях в правилах игры по сравнению с общепринятыми стандартами, наложенными многочисленными версиями игры TETRIS. Это позволяет сделать вывод о соответствии алгоритма постановке задачи. Выдача информации наглядна : на экране постоянно отображена игровая ситуация. Текст программы удобочитаем, т.к. содержит комментарии, поясняющие суть той или иной ситуации. Текст программы содержится в приложении.

Заключение.
В ходе курсовой работы мною были изучены некоторые аспекты программирования на языке Turbo Pascal. При оформлении курсовой работы был получены навыки оформления программной документации в соответствии с Единой Системой
Программной Документации, а также большой практический опыт работы в Turbo
Pascal v7.0, Microsoft Word 97, Meta Design v4.0, Microsoft Excel 97 ( хотя освоение этих программных продуктов не было целью курсовой работы, данные навыки нельзя считать бесполезными ). Теоретические сведения были закреплены практическими занятиями.

Литература.
1. В. Сустаков. Язык программирования Pascal. М.: Радио и связь. 1994.
2. К. Лыков. А. Бабонин. Язык программирования Pascal для персонального компьютера. М.: Радио и связь. 1993.
3. Н. Русаков и др. Справочник по функциям Borland Pascal 7.0. Киев:
Диалектика. 1994.
4. Р. Виземан. Word for Windows (программы для персональных компьютеров).
М.: Текст. 1994.
5. Excel 5.0 — английская и русская версии. СПб: BHV-Санкт-Петербург. 1994.

«ИГРА — вид непродуктивной деятельности, мотив которой заключается не в ее результатах, а в самом процессе. В истории человеческого общества переплеталась с магией, культовым поведением и др. … Свойственна также высшим животным».

Советский энциклопедический словарь

ВВЕДЕНИЕ

Все, кто имеет дело с компьютером, так или иначе сталкивались с компьютерными играми, и подавляющее большинство может сходу назвать несколько игр, которые им особенно понравились. Те, кто уже совсем наигрался, почти наигрался или еше не наигрался, но в процессе общения с компьютером уже начал совмещать игры с чем-нибудь более полезным, возможно, хотели бы придумать какие-нибудь свои, не похожие ни на какие другие игры
(1).

Многое захватывает в таком творчестве. И не сам процесс игры, а разработка игровой вселенной, ее проектирование и реализация. Когда можно слить воедино сценарий, графику, музыку, искусно задуманный и умело запрограммированный алгоритм — создать единый фантастический мир, живущий по законам, которые ты же для него и придумал.

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

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

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

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

Список использованных источников содержит полный перечень технической литературы, использованной для написания данной курсовой работы.

Приложения содержат блок-схемы всех процедур программы, и текст самой программы.

1. ПРОГРАММИРОВАНИЕ ИГР С ИСПОЛЬЗОВАНИЕМ ВИЗУАЛЬНЫХ КОМПОНЕНТОВ

1. Аналитический обзор

В последнее время продажи программного обеспечения увеличиваются незначительно, в то время как продажи игровых программ возрастают экспоненциально. Игры для платформы Windows составляют подавляющее большинство. Игровое программное обеспечение – это третья по размерам доходов отрасль индустрии программного обеспечения после текстовых процессоров и электронных таблиц (1).

До недавнего времени среда Windows использовалась в основном как платформа для создания игр, первоначально разработанных для Macintosh. Это осуществлялось на базе пакета QuickTime фирмы Apple. Примерами таких игр могут быть Mysl (Broderbund/Cyan), Wrath of the Gods (Maxis/Luminaria) и некоторые другие. В ряде случаев использовался пакет Video for Windows, позволяющий отображать оцифрованное видео. Затем появились библиотеки WinG и WinToon, на базе которых фирма Sierra создала игру King’s Quest VII. Это были первые попытки использовать Windows как платформу для создания игровых программ. Преимущества такого подхода достаточно очевидны — единый интерфейс, наличие стандартных драйверов для большинства мультимедийных устройств и возможность управления ими стандартными способами. Затем появилась новая версия — Windows 95, в состав которой была включена библиотека WinG (как подсистема GDI), и перед разработчиками открылись более широкие возможности.

Указать точное число компьютерных игр очень трудно. Можно только примерно оценить число различных наименований игр, находящихся на рынке в любое время (2).

Классификация компьютерных игр может быть следующая:
1. Приключенческие игры. Игры могут быть великолепным средством рассказа истории. Эти игры представляют собой мультиплицированный рассказ, в котором можно видеть и контролировать основной персонаж (а иногда и более одного) в очень детальном повествовании. Это — компьютерные версии обычных повествований, начиная от душещипательных рассказов до технотриллеров, научно-фантастических приключений, фантазий и рассказов, до предела набитых разными обманами и мошенничествами. Приключенческие игры развиваются вокруг различных загадок и препятствий, которые нужно преодолеть по мере развития рассказа.
2. Фантастические игры, в которых требуется играть некоторую роль (ролевые игры). Их лучше всего определить как компьютеризованную версию рассказа
Dungeons and Dragons («Подземелья и драконы»), но действие не всегда происходит в населенном варварами средневековом мире. Часто оно происходит в открытом космосе или в каких-либо областях будущего. В этих играх обычно нужно управлять группой персонажей, которые становятся по мере развития игры сильнее и умнее, и делать некоторые другие вещи. Так же изменяются и враги. Сами рассказы в играх этого типа обычно менее детальны, чем в приключенческих играх, с большим упором на задачу побить чудовгщ, чем решить загадки.
3. Имитаторы воздушных и космических сражений. Это не военные игры, в которых может оказаться неограниченное число вооружений и врагов, эти игры пытаются быть точными имитаторами полетов и сражений на реальных боевых самолетах. Эти игры предназначены для тех, кто хочет летать на больших и очень мощных машинах. Кабины пилотов выглядят как настоящие, инструменты работают как в настоящем бою, оружие является имитацией реально существующего, а полетные характеристики самолета (и самолета врага) соответствуют действительным. Имитаторы космических сражений выдуманы, однако они разработаны с целью точно повторить реальные маневры в космосе.
4. Имитаторы наземных и морских сражений. Игры разработаны для военного оборудования и военных машин. Эта категория игр включает в себя симуляторы настоящих подводных лодок, кораблей и танков, и позволяет игрокам испытать реальные сценарии сражений, и выжить для того, чтобы понять, как использовать правильную тактику в следующей игре.
5. Самолеты, поезда и автомобили. В отличие от этих имитаторов, все прочие являются имитаторами военного типа или имеют очень сильный упор на сражение. Эти же игры не относятся к таким имитаторам. Конечно, можно проехать на автомобиле по береговой дороге в Калифорнии со скоростью, вдвое превышающей разрешенную, и потанцевать на всех четырех колесах. Но также можно использовать эти игры, чтобы научиться безопасно летать среди облаков, и получать удовольствие от свободы полета. Даже можно делать такие вещи, как постройка и управление собственной железной дорогой.
6. Спортивные имитаторы. Здесь необходимо обучать профессионалов и управлять ими. Эти игры — нечто большее, чем простое изображение бейсбольных игр в картинках, в некоторых из них можно даже контролировать реальное действие. Спортивные имитаторы дают возможность вести рискованную игру в нужное время, доказать, что можно выиграть с помощью быстроты, иметь в команде Генри Аарона и Теда Вильямса, или переиграть Томми Лазорду.
7. Аркадные игры/игры действия. Это классические «игры действия» — все зависит от того, насколько быстро руки могут дергать джойстик. Обычно о них говорят как о бессмысленных, так часто и бывает. С другой стороны, бывают времена, когда появится потребность дать отдохнуть мозгам. Во многие из этих игр можно играть с помощью клавиатуры или мыши, и джойстики не всегда необходимы. В чем есть необходимость, так это в быстрых рефлексах.
8. Настольные игры, солитер и салонные игры. Многие старые любимые игры появились в компьютерном варианте. Больше не нужно заниматься поисками партнера, чтобы поиграть в шахматы, бэкграммон и риск. Некоторые из этих игр даже научат мошенничать наедине с монитором, и при этом не придется возвращаться домой с пустым карманом после неудачной ночи.
9. Имитаторы реальности («игры в бога»). Это игры, которые позволяют создавать реальный мир из ничего. Это игры, которые позволят создать компьютерный мир из набросков, управлять городом, страной или даже миром.
10. Игры, в которых делаются деньги. Они копируют игровую деятельность и учат высшим формам азартных предприятий: фондовая биржа, торговля недвижимостью. Они также позволят попробовать управлять корпорацией. В эти игры можно играть для удовольствия, или использовать их для того, чтобы научиться карабкаться вверх по лестнице карьеры.
11. Стратегические и военные имитаторы. Здесь можно принимать участие в великих исторических событиях, взять на себя командование немецкой армией у
Ленинграда или армией Наполеона у Ватерлоо. Это военные стратегии прошлого, настоящего или будущего.
12. Игры для детей. Если есть домашний компьютер, и чтобы дети научились его использовать, то эти игры достойны внимания. Реальность нашей культуры такова, что, как только малыши станут координированы настолько, чтобы правильно пользоваться клавиатурой или мышью, они хотят сразу приняться за такие игры, как Wing Commander, Populous или Eye of the Beholder. Однако же вокруг существует множество игр, в которые дети могут играть просто чтобы получить удовольствие, или же научиться чему-либо.
13. Игры «On-line». Было бы ошибкой считать, что все компьютерные игры для
IBM PC приходят к нам на дискетах или CD-дисках, плотно упакованных в красивые пакеты. Фактически, весь обширный мир компьютерных игр доступен и по телефону. Эта категория игр известна как «он-лайн» и включает в себя разнообразные игры, которые имеются в больших коммерческих «он-лайн» сетях и во многих локальных сетях типа «доска объявлений» (bulletin board system
— BBS). Для игр «он-лайн», кроме личного компьютера, необходимы модем и кредитная карточка.
14. Игры Shareware. Будет ошибкой предположить, что все компьютерные игры приходят в красивых упаковках. Многие хорошие игры приходят вовсе без упаковок, и стоят от 10 до 30 долларов. Обычно можно их опробовать за очень низкую плату или вовсе бесплатно в течение нескольких дней и, если захочется получить легальную копию, следует послать по почте чек компании или лицу, которые создали игру.
15. Классические игры. Мир PC-игр во многом похож на мир популярной музыки и фильмов: создается много игр различных наименований, некоторые становятся хитами и держат популярность в течение некоторого времени, другие пропадают. Постепенно эти хиты становится трудно отыскать, и мало-помалу они заменяются другими лучшими играми. Очень мало PC-игр живут более 2-3 лет. Из тех, что действительно остаются, многие настолько хороши, что становятся вечными, и они заслуживают того, чтобы в них играли. Некоторые, как Flight Simulator или King’s Quest, обновляются время от времени, так что их можно рассматривать как практически новые игры. Остальные остаются неизменными, и уровень продаж у них таков, что они остаются в обращении, но уже не рекламируются активно их производителями. Это игры, которые не бросаются в глаза, «золотые» игры — классические PC-игры.

Компьютерные игры — отнюдь не новое изобретение. Их история началась не с конца 1970 годов. Начало лежит гораздо раньше, тогда, когда Джон
Кеннеди уже пробыл президентом Соединенных Штатов всего несколько месяцев
(2).

На самом деле все началось с модели железной дороги. Студенты
Технологического института в Массачусетсе были немало удивлены количеством способов, с помощью которых можно было разместить органы управления миниатюрной железной дорогой. Позднее, когда они наконец получили возможность работать на больших компьютерах института, их работа в бинарных вычислениях — ведь именно такие вычисления имитируются выключателями железной дороги — позволили им пройти хорошую подготовку в компьютерном деле.

Стив Рассел был одним из членов Клуба Моделей Железных дорог Высокой
Технологии в Технологическом институте. Будучи хорошим программистом, он летом 1961 года работал в Статистической лаборатории, когда у него и его друзей появилась идея перенести «мыльные» научно-фантастические рассказы
Е.Е.Смита на компьютеры. В 1962 году Стив разработал программу для PDP-1.
Эта самая машина теперь выставлена в компьютерном музее Бостона в
Массачусетском Технологическом институте.

В «Космической Войне», как называлась эта программа, два синтезированных компьютером ракетных космических корабля (один похожий на толстую сигару, а другой на длинную обтекаемую трубу) могли летать по экрану, на котором помещалось изображение космоса. Игроки могли нажимать на кнопки, чтобы заставить ракеты менять направление движения почти так же, как позднее в игре Asteroids владельцы игровых машин Atari управляли своими кораблями. Каждая ракета несла на себе 31 торпеду, и, в то время как они летели по экрану, игрок мог выстрелить точечку из носа своей ракеты в направлении другой. Если точка действительно пересекала очертания другого корабля, программа определяла, что торпеда успешно поразила другой корабль и другой корабль «взрывался». Взорванный корабль пропадал с экрана и заменялся нагромождением точек, которые изображали его остатки.

Конечно, общество программистов и взломщиков программ не может удовлетвориться качеством любой программы, независимо от того, насколько она легка или интересна. Изменения были неизбежны. Один из друзей программиста, будучи недовольным случайным образом построенной картой звездного неба, которую Рассел первоначально поместил в игру, взял звездный атлас и ухитрился запрограммировать нашу собственную галактику, вплоть до звезд пятой величины. Другой добавил гравитацию в игру, а третий ввел возможность побега в гиперпространство, при этом, чтобы показать место, где корабль покинул звездную систему, на экране оставался след ускорения.

Даже Рассел сделал некоторые изменения. Зная, что у настоящих торпед вероятность поражения цели не 100%, а меньше, он решил придать звездным торпедам возможность ошибки, и добавить случайный элемент в траектории ракет и время взрыва. Его друзья терпеть не могли новую версию, поскольку они хотели бы иметь в игре ту же степень уверенности, которая существовала в программировании.

Рассел вернул программу к прежней версии и, не успели оглянуться, как
«Космические войны» оккупировали компьютеры колледжей по всей стране.

«Космические войны» стали настолько популярны к середине шестидесятых, что Нолан Бушнелл, создатель Atari, очень привязался к игре во время учебы в университете штата Юты. К 1970 году Бушнелл построил свою собственную машину, использовав 185 встроенных цепей для подсоединения к телевизору и для выполнения одной-единственной функции. Эта функция была игрой
«Компьютерный Космос», вариант «Космических Войн», в котором ракета сражалась с летающими тарелками вместо другого корабля.

«Космические Войны» были не единственным предшественником коммерческих компьютерных игр, появившихся на больших компьютерах в колледжах. Какой-то неизвестный автор начал играть в игру Star Trek («Звездный путь») в шестидесятых годах. Никто не знает, кто первым создал такую игру — он или она, вероятно, подали бы судебный иск, если бы автор игры был точно определен — но эта игра также появилась на колледжских компьютерах по всей стране к 1969 году.

Игра «Звездный путь» сама по себе была не очень изощренной. В игре были линии наподобие решеток, которые позволяли звездным кораблям путешествовать от одной точки к другой, игра использовала символы для идентификации кораблей, предоставляла численную информацию в процентах, и позволяла летать быстрее, чем скорость света. К середине 70-х годов почти на каждой домашней компьютерной системе была доступна та или иная форма этой игры. Существовала версия этой же игры для IBM под названием Star
Fleet («Звездный Флот»).

Наконец, стоит упомянуть пожалуй наиболее важную игру, Adventure
(«Приключения»). В игре использовались двухсловные команды, имя ее разработчика Вилл Краудер. Это была первая приключенческая компьютерная игра.

Кроме того, в конце 70-х была создана игра по имени Zork, которая стала доступна для пользователей домашних компьютеров в 1981 году. Эту игру до сих пор можно купить. Игра Zork основывается на игре Adventure (2).

2. Описание компонентов, используемых при реализации практической части курсовой работы

В практической части данной курсовой работы используются следующие визуальные и невизуальные компоненты (3, 4, 5) среды программирования
Borland Delphi 6.0.

1.2.1. Компонент TMainMenu

TMainMenu позволяет поместить главное меню в программу. При помещении
TMainMenu на форму это выглядит, как просто иконка. Иконки данного типа называют невидимым (невизуальным) компонентом, поскольку они невидимы во время выполнения программы. Создание меню включает три шага:
1) помещение TMainMenu на форму,
2) вызов Дизайнера Меню через свойство Items в Инспекторе Объектов,
3) определение пунктов меню в Дизайнере Меню.

Этот компонент доступен из модуля MENUS, и находится на странице
Палитры компонентов Standard

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

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

2. Объединение меню нужно при работе с интерфейсом MDI и его подокнами.

3. Механизм объединения меню используется серверами OLE, запускаемыми по месту нахождения объекта OLE. Загружаясь, сервер дописывает осуществляемые им операции к меню другого приложения.

Для того чтобы реализовать объединение меню, у тех форм, меню которых будут присоединены к главному, необходимо установить в True свойство: (Рb) property AutoMerge: Boolean.

При этом у главного меню оно должно оставаться равным False, иначе главное меню будет вообще невидимым. Объединение будет происходить автоматически при активизации новых форм или серверов OLE. Кроме автоматического режима, объединение меню можно выполнить при вызове метода: procedure Merge(Menu: TMainMenu).

Присоединяемое меню при необходимости может быть легко отсоединено вызовом метода: procedure Unmerge(Menu: TMainMenu).

При установленном в True свойстве AutoMerge ссылка на присоединенное меню будет сохраняться в специальном поле компонента и отсоединяться в нужных случаях автоматически (например, при закрытии формы, которой оно принадлежит).

Объединение меню происходит по специальным правилам, в основе которых лежит использование группового индекса (свойства Group Index) каждого объекта TMenuItem.

У пунктов меню одного уровня, в частности всех подменю верхнего уровня в главном меню, свойство GroupIndex является неубывающим, т. е. у последующего пункта групповой индекс больше либо равен индексу предыдущего.
Это требование отслеживается как на этапе разработки, так и на этапе исполнения. Например, пусть пункты меню имеют индексы 0, 3, 4, 5, 6. Если включить пункт меню с индексом 5 между пунктами с индексами 0 и 3, то 3 и 4 будут изменены на 5. А вот изменить большее значение Х на меньшее Y, если впереди есть пункты с индексом, большим Y, невозможно. Если в этом примере попытаться изменить индекс 6 на 4, то это приведет к возникновению исключительной ситуации EMenuError.

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

1. если в присоединяемом меню есть пункты с таким же групповым индексом, что и в исходном, то все их множество заменяет все множество таких пунктов в исходном меню;

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

К окнам интерфейса MDI все сказанное относится только при запуске приложения. Если в формах приложения со стилем fsMDIChild есть свои главные меню, то в этот момент они автоматически сольются с главным меню формы fsMDIForm независимо от состояния AutoMerge.

На уровне работы с серверами OLE предусмотрены дополнительные возможности по объединению меню. Если в компонент TOLEContainer загружен объект OLE, то в конец подменю Edit обычно добавляется подменю, из которого можно вызвать функции открытия и редактирования этого объекта. После активизации сервера он может не только вставлять свои подменю в главное, но и добавлять новые пункты к уже существующим подменю.

Три метода TMainMenu используются для работы с меню OLE:

1. procedure PopulateOle2Menu(SharedMenu: HMenu; Groups: array of

Integer; var Widths: array of Longint);

2. procedure GetOle2AcceleratorTable(var hAccel : THandle; var numAccels:

Word; Groups: array of Integer) ;

3. procedure Set01e2MenuHandle(Handle: HMENU);
1.2.2. Компонент TLabel

TLabel служит для отображения текста на экране. Можно изменить шрифт и цвет метки, если дважды щелкнуть на свойство Font в Инспекторе Объектов. Видно, что это легко сделать и во время выполнения программы, написав всего одну строчку кода.

Этот компонент доступен из модуля STDCTRLS, и находится на странице
Палитры компонентов Standard.

Компонент представляет собой статический текст. С помощью этого компонента на рабочей поверхности формы можно отобразить информацию, сделать пояснения и показать названия других компонентов. Но он имеет и другую важную функцию — если в составе текста TLabel есть символы- акселераторы, информация об их нажатии может передаваться от TLabel другому элементу управления.

Свойства компонента приведены в табл.1:

Таблица 1

Свойства компонента TLabel

|Свойство |Описание |
|(Pb) property Caption: TCaption; |Содержит строку с выводимым текстом. |
|TCaption = string[255]; | |
|(Pb) property Alignment: |Устанавливает правило выравнивания |
|TAlignment; |текста — по правому, левому краю или по|
| |центру клиентской области. |
|(Pb) property AutoSize: Boolean; |В случае True происходит автоматическое|
| |приведение размеров компонента к |
| |размерам текста и высоте шрифта. |
| | |
| | |
| |Продолжение табл.1 |
|(Pb) property ShowAccelChar: |Показывает, отображается ли в TLabel |
|Boolean; |акселератор (символ, перед которым |
| |стоит знак амперсанда — ‘&’). Если оно |
| |равно False, амперсанд никак не |
| |интерпретируется. В случае True |
| |акселератор выделяется в строке |
| |подчеркиванием и нажатие клавиш |
| |+ приводит к передаче |
| |фокуса окну FocusControl (т.к. TLabel |
| |сам не является оконным компонентом). |
|(Pb) property FocusControl: |Определяет оконный компонент, которому |
|TWinControl; |посылаются сообщения о вводе |
| |акселератора. |
|(Pb) property Transparent: |Прозрачность фона компонента. Если |
|Boolean; |свойство установлено в True, то при |
| |перерисовке элемента управления не |
| |происходит закрашивание клиентской |
| |области. В противном случае — |
| |происходит закрашивание кистью bsSolid |
| |и цветом Color. |
|(Pb) property WordMrap: Boolean; |Определяет возможность разрыва слов в |
| |случае, если длина выводимого текста |
| |превышает ширину компонента. |

1.2.3. Компонент TPanel

TPanel — управляющий элемент, похожий на TGroupBox, используется в декоративных целях. Чтобы использовать TPanel, просто поместите его на форму и затем положите другие компоненты на него. Теперь при перемещении
TPanel будут передвигаться и эти компоненты. TPanel используется также для создания панели инструментов и окна статуса.

Этот компонент доступен из модуля EXTCTRLS, и находится на странице
Палитры компонентов Standard.

Этот компонент — является несущей конструкцией для размещения других элементов управления. В отличие от простой рамки (TBevel) панель сама является оконным элементом управления и родителем для всех размещенных на ней компонентов. Часто ее используют для создания панелей инструментов, строк состояния и т. п.

За внешнее оформление панели отвечают свойства:

(Pb) property Bevel Inner: TPanelBevel;

(Рb) property BevelOuter: TPanelBevel;

TPanelBevel = (bvNone, bvLowered, bvRaised) ;

(Pb) property BevelWidth: TBevelWidth;

TBevelWidth = 1..Maxint;

(Pb) property BorderWidth: TBorderWidth;

TBorderWidth = 0..Maxint ;

На границах панели размещаются две специальные окаймляющие рамки
(bevels): Bevellnner и BevelOuter. При помощи комбинации белого и серого цветов они имитируют трехмерность — приподнятость (bvRaised) или утоп- ленность (bvLowered). Обе рамки имеют ширину BevelWidth. Наружная —
BevelOuter — расположена прямо по периметру панели, вторая — Bevellnner — внутри на расстоянии BorderWidth от нее. Обе могут быть невидимыми
(bvNone), приподнятыми или утопленными.

Комбинируя сочетания bvLowered/bvRaised, можно создать вокруг панели
«ров» или «вал».

Иллюзию трехмерности может подчеркнуть также стиль обрамления компонента:

(Pb) property BorderStyle: TBorderStyle;

TBorderStyle = bsNone .. bsSingle;

Значение bsSingle означает, что панель будет окаймлена черной линией единичной толщины (по периметру, снаружи от обеих рамок).

Выравнивание текста заголовка панели определяется при помощи свойства:

(Pb) property Alignment: TAlignment;

Свойство (Pb) property Locked: boolean; предназначено для определения способа взаимодействия панели с размещенными на ней объектами OLE. Если оно равно True, последние при активизации сервера OLE «по месту'» не могут заместить панель.

В обработчике события: (Pb) property OnResize: TNotifyEvent; может быть предусмотрена реакция пользователя на изменение размеров панели.

1.2.4. Компонент TBitBtn

TBitBtn — кнопка вроде TButton, однако на ней можно разместить картинку
(glyph). TBitBtn имеет несколько предопределенных типов (bkClose, bkOK и др), при выборе которых кнопка принимает соответствующий вид. Кроме того, нажатие кнопки на модальном окне (Form2.ShowModal) приводит к закрытию окна с соответствующим модальным результатом (Form2.ModalResult).

Этот компонент доступен из модуля BUTTONS, и находится на странице
Палитры компонентов Additional.

Эта кнопка, будучи потомком TButton, может нести на себе пиктограмму и имеет рад дополнительных удобств в использовании. В Delphi уже определены стандартные виды кнопок:

(Pb) property Kind: TBitBtnKind;

TBitBtnKind = (bkCustom, bkOK, bkCancel, bkHelp, bkYes, bkNo, bkClose, bkAbort, bkRetry, bklgnore, bkAll);

Для каждой из них определены: передаваемый форме результат
(ModalResult):

BitBtnModalResults: array[TBitBtnKind] of TModalResult =
(0, mrOk, mrCancel, 0, mrYes, mrNo, 0, mrAbort, mrRetry, mrlgnore, inrAll); а также название и картинки для разных состояний. Достаточно установить значение свойства Kind, и кнопка сразу приобретет нужный вид. Более того, некоторые из видов кнопок при нажатии сразу совершают определенные действия. Так, bkHelp осуществляет инициализацию системы помощи со своим
(или ближайшим ненулевым родительским) контекстом. Кнопка вида bkClose закрывает форму, которой она принадлежит, вызывая ее метод Close.

Кнопка будет отнесена к виду bkCustom, если она:

1. назначена Default, но при этом не принадлежит множеству [bkOk, bkYes];

2. назначена Cancel, но не принадлежит множеству [bkCancel, bkNo];

3. у нее изменена пиктограмма;

4. модальный результат не соответствует определенному для этого вида кнопок.

За внешний вид этой кнопки отвечают свойства, рассмотренные ниже.
Стиль изображения кнопок в зависимости от операционной системы задается свойством:

(Pb) property Style: TButtonStyle;

TButtonStyle = (bsAutoDetect, bsWin31, bsNew);

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

(Pb) property Glyph: TBitmap;

Для создания эффекта нажатия картинка должна немного изменяться в зависимости от состояния; кроме того, отдельная картинка нужна для неактивного состояния (когда нажатие не воспринимается). В свойстве Glyph должна быть одна битовая карта, но она может содержать картинки сразу для нескольких состояний кнопки (максимум четыре). Они интерпретируются как соответствующие нормальному (отжатому), запрещенному (неактивному), нажатому и утопленному состояниям (последнее применяется только для кнопок
TSpeedButton). Для этого картинки должны быть расположены подряд вплотную по горизонтали. Например, при размере картинок 16х16 нужна объединенная битовая карта 64х16. Если каждая из картинок квадратная и ширина общей картинки нацело делится на высоту, то при присвоении ее свойству Glyph система сможет распознать их и скорректировать количество, определяемое свойством:

(Pb) property NumGlyphs: TNumGlyphs ;

TNumGlyphs = 1..4;

При отрисовке в зависимости от состояния из большой битовой карты будет использована нужная часть.

Три свойства отвечают за расположение текста и картинки на поверхности кнопки:

(Pb) property Layout: TButtonLayout;

Способ выравнивания пиктограммы относительно краев кнопки. Может быть одним из четырех:

TButtonLayout = (biGlyphLeft, biGlyphRight, biGlyphTop, biGlyphBottom);

Расстояние от соответствующего способу выравнивания края кнопки до пиктограммы описывается свойством:

(Pb) property Margin: Integer;

Промежуток между пиктограммой и текстом равен:

(Pb) property Spacing: Integer;

Если свойства Margin, Spacing или оба не заданы (по умолчанию равны
-1), значения этих промежутков выбираются системой. Кнопка также имеет метод Click и свойства Caption, ModalResult, Default и Cancel. Статус
Default получают кнопки видов bkOk, bkYes, a Cancel — кнопки видов bkCancel, bkNo.

1.2.5. Компонент TSpeedButton

TSpeedButton — кнопка для создания панели быстрого доступа к командам
(SpeedBar). Пример — SpeedBar слева от Палитры Компонент в среде Delphi.
Обычно на данную кнопку помещается только картинка (glyph).

Этот компонент доступен из модуля BUTTONS, и находится на странице
Палитры компонентов Additional.

Эта кнопка с изображением может иметь как зависимую, так и независимую фиксацию. Она удобна для применения в составе панелей инструментов.
Поведение этих кнопок во многом определяется свойством:

(Pb) property Grouplndex: Integer;

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

(Pb) property AllowAlIUp: Boolean; которое описывает поведение кнопок в группе, а именно: могут ли все кнопки одновременно быть отжаты. Если AllowAlIUp равно False (по умолчанию), нажатую кнопку в группе можно отпустить, лишь нажав другую. Если AllowAlIUp равно True, кнопку можно отпустить повторным нажатием.

Если необходимо фиксировать одну кнопку TSpeedButton, ей нужно присвоить уникальный групповой индекс, а AllowAlIUp установить в True.

Поскольку в группе не могут одновременно находиться кнопки с различным значением этого свойства, при нажатии кнопки и изменении Grouplndex свойство AllowAlIUp «рассылается» (присваивается) остальным кнопкам с тем же значением Grouplndex. В группе не может быть нажато более одной кнопки.
Определяет, нажата ли кнопка, свойство:

(Pb) property Down: Boolean;

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

Текст кнопки определяет свойство Caption. Компонент имеет те же правила и свойства рисования картинки, что и TBitBtn. Они описываются свойствами Glyph, NumGlyphs, Layout, Margin и Spacing.

Для имитации щелчка предусмотрен метод Click. Двойной щелчок для
TSpeedButton возможен только на нажатой кнопке — иначе он интерпретируется как обычный. Описывается свойством:

(Pb) property OnDblClick;

1.2.6. Компонент TImage

TImage — отображает графическое изображение на форме. Воспринимает форматы
BMP, ICO, WMF. Если картинку подключить во время дизайна программы, то она прикомпилируется к EXE файлу.

Этот компонент доступен из модуля EXTCTRLS, и находится на странице
Палитры компонентов Additional.

Этот компонент служит надстройкой над классом TPicture и замыкает всю иерархию графических объектов VCL. Он предназначен для показа на форме изображения: битовой карты (TBitmap), метафайла (TMetafile), значка
(TIcon).

Свойство (Pb) property Picture: TPicture; служит контейнером для графического объекта одного из перечисленных классов.

В качестве канвы используется канва объекта Picture. Graphic — только если поле Graphic ссылается на объект класса TBitmap:

(Pb) property Canvas: TCanvas;

Если это не так, то попытка обращения к свойству вызовет исключительную ситуацию EInvalidOperation, так как рисовать на метафайле или значке нельзя.

Следующие три свойства определяют, как именно Tpicture располагается в рабочей области компонента:

(Pb) property AutoSize: Boolean;
— означает, что размеры компонента настраиваются по размерам содержащегося в нем графического объекта. Устанавливать его в True нужно перед загрузкой изображения из файла или буфера обмена;

(Pb) property Stretch: Boolean;
— если это свойство установлено в True, то изображение «натягивается» на рабочую область, при необходимости уменьшая или увеличивая свои размеры.
Если оно установлено в False, то играет роль следующее свойство;

(Pb) property Center: Boolean;
— если это свойство установлено в True, изображение центрируется в пределах рабочей области. В противном случае — располагается в ее верхнем левом углу.

1.2.7. Компонент TTimer

TTimer — таймер, событие OnTimer периодически вызывается через промежуток времени, указанный в свойстве Interval. Период времени может составлять от
1 до 65535 мс.

Этот компонент доступен из модуля EXTCTRLS, и находится на странице
Палитры компонентов System.

Этот невизуальный компонент предназначен для уведомления программы об истечении определенных промежутков времени. Компонент инкапсулирует системный таймер Windows и работает через посылку сообщений WM_TIMER.

Свойство (Pb) property Enabled: Boolean; включает/выключает таймер, влияя на генерацию им событий. Будучи установлен в Enabled, таймер начинает генерировать события OnTimer через интервал времени

(Рb) property Interval: Word; который измеряется в миллисекундах. После каждого истечения такого интервала инициируется обработчик, связанный с событием:

(Pb) property OnTimer: TNotifyEvent;
При этом программист получает очередной квант времени.

При активизации и деактивизации таймера или изменении интервала в системе может не оказаться свободных таймеров. В этом случае генерируется исключительная ситуация EOutOfResources.

1.2.8. Компонент TStatusBar

TStatusBar – строка состояния. Предназначена для размещения разного рода служебной информации в окнах редактирования, обычно располагается в нижней части основной формы. Компонент может иметь несколько секций, а также кнопку изменения размеров окна, в которое он помещен. С компонентом связывается объект класса TStatusPanel, который определяет панели компонента.

Этот компонент находится на странице Палитры компонентов Win32.

2. РАЗРАБОТКА ПРОГРАММЫ

2.1. Постановка задачи

Разработать игровую программу «Морской бой», которая включает игровую панель, состоящую из двух полей для человека и компьютера. На поле расставляются 10 кораблей разного класса. Четыре корабля размером в одну ячейку, три корабля размером в две ячейки, два корабля размером в три ячейки, и один корабля размером в четыре ячейки. Поочередно противникам предоставляется возможность выстрела по чужому полю, результаты которого отображаются на нем. При попадании в корабль предоставляется возможность дополнительного выстрела. Победа присуждается игроку, потопившему все корабли противника.

Справочная информация содержит правила игры, версию программы, и автора работы.

2.2. Алгоритм реализации работы

2.2.1. Алгоритм реализации игровой программы

Запуск программы осуществляется следующим образом: необходимо открыть папку, содержащую данную игру, и найти исполняемый файл morboy.exe. На этом файле следует выполнить двойной щелчок левой клавишей манипулятора мышь.

Проект программы состоит из файла проекта, содержащего необходимые конструкции для исполнения, и двух модулей Unit1 и Unit2 (6, 7, 8).

Модуль Unit2 содержит форму AboutBox, и предназначен для вывода окна, содержащего информацию о программе и об авторе (рис.1).

[pic]

Рис.1. Информация о программе

Модуль Unit1 является основным модулем проекта, содержащим все необходимые для работы программы процедуры.

После запуска программы на экран выводится основная форма Form1
(рис.2), на которой расположены следующие объекты:

1. Главное меню

2. Игровое поле компьютера

3. Игровое поле человека

4. Кнопки подтверждения / отмены хода

5. Строка состояния

[pic]

Рис.2. Вид программы после запуска

Игра, т.е. работа программы, начинается с выбора в главном меню пункта
«Игра», в котором содержится подпункт «Новая». После выбора этого подпункта, или нажатия клавиши F2, происходит выполнение процедуры
N11Click. Эта процедура предназначена для расстановки кораблей на игровых полях случайным образом (Приложение 1).

Первоначально на форму выводится сообщение «Ваш ход» (блок 2). Далее переменным P и t1 присваиваются значения True, и инициализируется генератор случайных чисел (блок 3). Затем организуется цикл с заданным количеством повторений по переменной U от 1 до 2 (блок 4). В этом цикле, в свою очередь организуются два вложенных цикла с заданным количеством повторений, в которых происходит обнуление элементов массива записи (блоки 5, 6 и 7).
После этого выполняется операция присваивания m[u].k:=20 (блок 8). Это – общее количество ячеек, которое занимают все корабли одного игрового поля.

Далее организуются два вложенных цикла, первый с параметром I от 4 до
1 с шагом –1, второй с параметром j от 1 до 5-I с шагом 1 (блоки 9 и 10). В этих циклах выполняется расстановка кораблей случайным образом. Внутри этих циклов организуется еще один цикл типа «До» с условием окончания цикла t=True (блок 32). В теле цикла происходит операция присваивания t:=true
(блок 11), и проверяется многовариантное условие, чему равно значение выражения random(2), сгенерированное случайное число, нулю или единице.
Если это выражение рано нулю (блок 12), будет происходить установка корабля по горизонтали и будут выполнены следующие действия: генерируются случайным образом координаты X1 и Y1 (блок 13), организуется цикл с заданным числом повторений по переменной X (блок 14), в котором проверяется условие неравенства нулю ячейки с координатами X,Y1 (блок 15), и если это так, то переменной t присваивается значение False (блок 16).

И, в этом же цикле проверяется условие истинности переменной t. Если переменная t=True (блок 17), то происходит пропуск некоторых ячеек (блок
18), и установка ячеек корабля (значение ячейки равно 2) циклически (блоки
19 и 20). После этого опять происходит пропуск некоторых ячеек (значение их равно 1) (блок 21). На этом цикл завершается (блок 14), и проверяется следующее значение выражения random(2). Если это выражение равно единице
(блок 22), то происходит установка корабля по вертикали. Все выполняемые действия этой ветки алгоритма аналогичны вышеописанным, с применением циклов по переменной Y (блоки 23 — 31).

После выполнения этих действий проверяется условие окончания цикла
«До» (блок 32), и завершаются два вложенных цикла по переменным I и J
(блоки 9 и 10).

Далее, происходит визуальная расстановка кораблей на игровом поле человека. Для этого организуются два вложенных цикла по переменным I и J со значениями от 1 до 10 (блоки 33 и 34). В циклах проверяется условие заполнения ячейки поля клеткой корабля m[1].a[i,j]=2 (блок 35), и если это логическое выражение истинно, то переменной r присваивается название файла, содержащего картинку корабля (блок 37), иначе – пустую картинку (блок 36).
Далее, с помощью двух процедур Case1 происходит прорисовка ячеек на игровом поле (блоки 38 и 39).

Последние действия в этой процедуре – вывод на панель строки состояния значений количества выстрелов и попаданий (блок 40), а также происходит присваивание переменным следующих значений: tm1:=Time и new:=True.

Процедура Case1, про которую было сказано выше, выполняет следующие действия (Приложение 2): при обращении к определенной ячейки игрового поля человека или компьютера происходит прорисовка ячейки специальной картинкой, в зависимости от значения переменной r. В процедуре происходит множественный выбор, по номеру ячейки, и выполняется действие загрузки растрового файла в компонент TSpeedButton (блоки 2 — 401).

После того, как все корабли были расставлены на игровом поле, программа ожидает срабатывания нескольких событий:

. щелчка левой клавишей манипулятора мышь по ячейки игрового поля компьютера;

. выбора из пункта «Игра» главного меню подпункта «Выход»;

. выбора из пункта «Помощь» главного меню подпункта «О программе»;

. выбора из пункта «Помощь» главного меню подпункта «Правила игры»

При описанном первым событии происходит обращение к процедуре
SpeedButton101Click (Приложение 3). В теле процедуры сразу проверяется переменная t1. Если t1 не равна значению True (блок 2), то процедура завершает свою работу, иначе происходит присвоение переменной S имени объекта игрового поля, по которому производится щелчок, из имени объекта удаляется подстрока «SpeedButton», оставшийся номер объекта преобразуется в число (блок 3). После этого проверяется условие, делится ли это число на 10 с остатком (блок 4). Если это так, то переменной J присваивается значение I-
90 (блок 6), иначе J=I-100 (блок 5). Далее, проверяется делимость числа J на 10 без остатка (блок 7). Если это условие выполняется, то переменной U присваивается значение 10 (блок 9), иначе вычисляется остаток от деления переменной J на 10 (блок 8). Полученное значение переменной U проверяется с использованием многовариантного выбора, и в соответствии со значением переменной S присваивается одна из букв русского алфавита, от А до К (блоки
10 — 29). Потом проверяется условие, был ли щелчок на данной ячейке (блок
30), если щелчка не было, то осуществляется переход на положительную ветку алгоритма, в которой, во-первых, осуществляется вывод в ячейку картинки, показывающей сделанный ход (блок 31), во-вторых, происходит вывод над игровым полем человека кода произведенного хода (блок 32), и в-третьих, переменной t1 присваивается значение False, и кнопки подтверждения / отмены хода становятся доступными (блок 33). На этом процедура завершает свою работу (блок 34).

При подтверждении сделанного хода, т.е. при щелчке на кнопке OK, происходит вызов процедуры BitBtn1Click (Приложение 4), которая производит так называемый выстрел, и в соответствии с этим, отмечает необходимые ячейки игровых полей.

После вызова процедуры происходит приращение переменной KL на единицу
(блок 2), и проверяется ячейка игрового поля (блок 3). Если в ячейке есть клетка корабля, то выводится соответствующая картинка с помощью процедуры
Case1 (блок 4), уменьшается счетчик количества клеток кораблей, и соответствующая клетка помечается как использованная (значение равно 3)
(блок 5). Далее, происходит проверка количества «живых» клеток кораблей.
Если это количество равно нулю (блок 6), то выводится сообщение «Победа!»
(блок 7), переменным P и t1 присваивается значение False, кнопки подтверждения / отмены хода становятся неактивными (блок 8), и процедура завершает свою работу (блок 19).

Если количество «живых» клеток кораблей не равно нулю (блок 6), то выводится сообщение «Попал!» (блок 9), и переменной P присваивается логическое значение False (блок 10). При этом происходит объединение этой ветки алгоритма с веткой «Нет» блока условия 3 (пустая клетка), в которой выводится сообщение «Промах» (блок 11), соответствующая ячейка заполняется необходимым изображением с помощью процедуры Case1 (блок 12), ячейка помечается, как использованная (значение равно 3), и переменной P присваивается логическое значение True (блок 13).

Далее, переменной t1 присваивается логическое значение True, вычисляется результативность S (блок 14). На панель 2 строки состояния выводятся значения количества выстрелов, количества попаданий и результативность игрока (блок 15), кнопки подтверждения / отмены хода становятся неактивными (блок 16), и проверяется значение переменной p (блок
17). Если это значение равно True, то происходит вызов процедуры Komp (блок
18), которая производит ход компьютера.

Процедура Komp (Приложение 5) начинается с двух вложенных циклов типа
«До», в которых вычисляются координаты выстрела случайным образом (блок 2).
После этого проверяется условие завершения внутреннего цикла (блок 3).
Далее происходит многовариантная проверка координаты по вертикали В1 от 1 до 10, в результате которой переменной S присваивается определенное значение, лежащее в промежутке от А до К (блоки 4 — 23).

Выводится код хода компьютера над игровым полем (блок 24), и соответствующим образом заполняется ячейка игрового поля, переменной PK присваивается необходимое логическое значение (блоки 25 — 29).

Далее, происходит приращение количества выстрелов, вычисляется результативность (S) (блок 30), и на панель 0 строки состояния выводятся значения количества выстрелов, количества попаданий, и результативность
(блок 31).

Потом, проверяется условие завершения внешнего цикла «До» (блок 32), и если условие выполняется, то процедура заканчивает свою работу (блок 33).

При отмене сделанного пользователем хода, т.е. при щелчке на кнопку
NO, происходит вызов процедуры BitBtn2Click (Приложение 6). В этой процедуре очищается ячейка игрового поля с помощью процедуры Case1 (блок
2), переменной t1 присваивается логическое значение True, и кнопки подтверждения / отмены хода становятся неактивными (блок 3).

В этом же приложении приведена процедура Timer1Timer (Приложение 6), которая основана на невизуальном компоненте Timer, и рассчитывает время игры. Здесь, если выполняется условие new=True (блок 2), то на панель 1 строки состояния выводится значение времени игры (блок 3).

Все процедуры находится в модуле Unit1, текст которого приведен в приложении 7.

2.2.2. Реализация справочной информации

Справочная информация (правила игры) реализована с помощью программы
Help Development Studio. Эта программа позволяет создать файл справочной информации для Windows, используя текст формата Rich Edit Text. В процессе работы этой программы создается файл проекта справки *.hmp, который впоследствии может быть откомпилирован в файл справки (*.hlp).

В данной курсовой работе был создан файл проекта справки morboy.hmp, который был откомпилирован с помощью программы Help Development Studio,
Microsoft Help WorkShop, входящей в состав Borland Delphi 6.0, и компилятора HcRtf.exe в файл morboy.hlp (рис.6).

2.3. Описание пользовательского интерфейса

После запуска программы на экран выводится основное окно программы
(рис.2). Необходимо вызвать главное меню и выбрать из пункта «Игра» подпункт «Новая» (рис.3).

[pic]

Рис.3. Программа с открытым главным меню

После выбора происходит расстановка кораблей, и игра начинается
(рис.4).

[pic]

Рис.4. Игра

Игроку предоставляется право первого хода. Ход осуществляется путем щелчка левой кнопкой мыши на игровом поле. После щелчка по клетке поля на ней появляется изображение мины (рис.4), и игроку предоставляется право подтвердить или отменить ход с помощью кнопок OK и No. После подтверждения в ячейке появляется изображение результата хода, а в нижней левой части окна появляется сообщение о результате: «Попал» (рис.4) или «Промах!». Если был произведен результативный выстрел, то игроку дается право внеочередного хода. В противном случае право хода передается компьютеру. Победа присуждается за все потопленные корабли, и на этом игра заканчивается
(рис.5).

Горячие клавиши, применяемые при работе программы:

1. Alt+И – Вызов пункта «Игра» главного меню

2. F2 – Новая игра

3. F10 – Выход в систему

4. Alt+N – Отмена хода

[pic]

Рис.5. Победа в игре

Если в процессе игры пользователю необходимо обратиться к правилам, то с помощью пункта «Помощь» главного меню можно вызвать подпункт «Правила игры». В результате появится окно справки, показанное на рис.6.

[pic]

Рис.6. Окно справки

ЗАКЛЮЧЕНИЕ

В результате выполнения данной курсовой работы был получен игровой программный продукт, названный «Морской бой». Было проведено исследование компонентов программной среды Borland Delphi 6.0, которые использовались при создании игры.

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

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

2. При полном потоплении корабля это никак не отражается;

3. Невозможность возврата на несколько ходов назад;

4. Работоспособность приложения только в среде Windows;

5. Невозможность ручной расстановки кораблей игрока.

Однако, помимо недостатков, есть и достоинства у этого программного продукта:

1. Есть возможность отменить неверно сделанный ход с помощью кнопок подтверждения / отмены;

2. Создана интерактивная справка с правилами игры;

3. Программный продукт малотребователен к системным ресурсам компьютера.

Минимальная конфигурация: процессор – не ниже Pentium, оперативная память – не ниже 16 Mb, операционная система – Windows 95 / 98/ Me /

NT / 2000 / XP.

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

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1. Журнал Компьютер Пресс, N1, 1996

2. Дворак Дж. 350 игр для IBM PC. –С-Пб.:Пергамент, 1994, -318с.

3. Фаронов В.В. Delphi 4. Учебный курс. –М.: Нолидж, 1999. -447с.

4. Дарахвелидзе П.Г., Марков Е.П. Delphi – среда визуального программирования. –СПб.:BHV-Санкт-Петербург, 1996. -352с.

5. Епанешников А., Епанешников В. Программирование в среде Delphi 2.0.

Учебное пособие. В 4-х частях. Ч.1. Описание среды. –М.:ДИАЛОГ-МИФИ,

1997. -235с.

6. Епанешников А., Епанешников В. Программирование в среде Delphi 2.0.

Учебное пособие. В 4-х частях. Ч.2. Язык Object Pascal 9.0. –М.:ДИАЛОГ-

МИФИ, 1997. -319с.

7. Фаронов В.В. Турбо Паскаль 7.0. Начальный курс. Учебное пособие.

–М.:Нолидж, 1997. -616с.

8. Фаронов В.В. Турбо Паскаль 7.0. Практика программирования. Учебное пособие. –М.:Нолидж, 1997. -432с.

————————
[pic]

[pic]

[pic]

[pic]

[pic]

[pic]

[pic]

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

заранее известные (то есть те, на которые ориентированы системы защиты);

неизвестные (тех, которые не были учтены при построении системы безопасности).

Именно, вторая категория причин является наиболее опасной. Система контроля за безопасностью работы, наблюдая, поставляет сведения для специалистов, отвечающих за безопасность работы на данном рабочем месте.

Эти сведения подвергаются анализу, который в свою очередь под

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

Полный анализ опасностей состоит из трех этапов :

общий анализ;

детальный анализ;

определение экономической эффективности устранения опасностей.

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

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

Другой метод — использование “деревьев отказов”. Метод “деревьев отказов” является логическим методом локализации наиболее опасных участков системы. Суть его заключается в отыскании оптимального решения по возможности снижающего вероятность несчастного случая. Он дает информацию о том, как наиболее эффективно следует распределить средства, чтобы получить наибольший экономический эффект от их вложения.

Под экспертной системой понимается комплекс программ программ для ЭВМ или специальное устройство, способное накапливать или обобщать знания и эмпирический анализ эксперимента в какой-то проблемной области, а затем работать в качестве советчика при рядовом специалисте.

Экспертные системы работают в 2-х режимах : режим приобретения знаний и режим решения задач. В первом случае в общении с экспертной системой участвует эксперт (специалист в рассматриваемой области), он наполняет систему значениями (правилами), во втором режиме в соответствии с вводимыми продукционными правилами, система принимает окончательное решение.

Типы экспертных систем (Э.С.).

Интерпретирующие Э.С. (системы идентификации химических структур на основе данных спектрального анализа).

Системы автоматического проектирования (расчета конфигурации ЭВМ, проектирование топологии локальных вычислительных сетей).

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

Диагностические системы (системы медицинской диагностики).

Автоматизированные, обучающие системы (предоставляют возможность пользователю давать ответы и анализировать ошибки в процессе деятельности (тренажеры)).

Требовалось построить Э.С. по анализу опасности, в данном случае на примере :

Рабочее место — фрезерный станок. Выполняемая операция — обработка заготовки. После многократного наблюдения операция была разбита на следующие действия :

закрепили заготовку ;

включили станок ;

подвели резец;

обработали заготовку;

отвели резец;

выключили станок.

Кроме того в работе выделены следующие элементы опасности :

электротравма;

попадание древесной пыли в глаза;

касание рукой движущихся частей машины.

В анализе опасности использовали метод “Деревьев отказов”.

Опасность I.

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

1. Плохое техническое оснащение станка :

а) неисправность изоляции;

б) отсутствие зануления.

2. Неблагоприятная обстановка в цехе :

а) сырость;

б) обрыв проводов;

в) другие ситуации.

3. Не соблюдение техники безопасности оператором :

а) ликвидация неисправности при включенном станке ;

б) мусор на рабочем месте.

Опасность II.

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

1. Виноват оператор :

а) оператор забыл надеть защитные очки;

б) оператор не опустил защитный щиток.

2. В зоне станка посторонний :

а) неоператор попадает в рабочую зону станка;

б) неоператор пришел за инструментом;

в) неоператор уносит бракованные заготовки;

г) другие причины.

3. Вспомогательное оборудование :

а) сгорел вентиляционный двигатель;

б) закупорился вентиляционный канал;

в) вентиляция отключена из-за ремонта.

Опасность III.

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

1. Вина оператора :

а) оператор поправляет заготовку;

б) оператор забыл опустить щиток;

в) оператор чинит станок;

г) кто-то посторонний в рабочей зоне;

д) еще что-то отвлекло оператора.

2. Авария :

а) ударило током;

б) пыль попала в глаза;

в) потерял сознание;

г) оператор был в нетрезвом состоянии.

Работа с программой осуществляется следующим образом :

1. Строятся “Деревья отказов” и в файл делают запись событий приводящих к травме;

2. Вводят тип формулы подсчета вероятности (в процентах);

Виды формул подсчета вероятностей :

,

по “ и ”;

,

по “ или ”;

в) возможны варианты.

3. Записывают предполагаемые затраты на исправление данных ситуаций;

4. Указывается тип производства.

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

а) безопасности жизнедеятельности;

б) наименьшей сметы затрат.

Если одновременно не получается, т. е. возможно (а) но невозможно (б), то выдает сообщение о различии, но ставит на первое место безопасность человека, проверяя, соответствует ли данная альтернатива стандартам введенного типа производства.