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

ЛИЧНЫЙ КАБИНЕТ 

 

Здравствуйте гость!

 

Логин:

Пароль:

 

Запомнить

 

 

Забыли пароль? Регистрация

Повышение уникальности

Предлагаем нашим посетителям воспользоваться бесплатным программным обеспечением «StudentHelp», которое позволит вам всего за несколько минут, выполнить повышение уникальности любого файла в формате MS Word. После такого повышения уникальности, ваша работа легко пройдете проверку в системах антиплагиат вуз, antiplagiat.ru, etxt.ru или advego.ru. Программа «StudentHelp» работает по уникальной технологии и при повышении уникальности не вставляет в текст скрытых символов, и даже если препод скопирует текст в блокнот – не увидит ни каких отличий от текста в Word файле.

Результат поиска


Наименование:


курсовая работа Динамические структуры данных. Линейный однонаправленный список с головным элементом

Информация:

Тип работы: курсовая работа. Добавлен: 05.12.2012. Сдан: 2012. Страниц: 30. Уникальность по antiplagiat.ru: < 30%

Описание (план):



 
 
 
 
 
 
 
 
 
Курсовой  проект
по дисциплине "Технологии программирования"
Тема: «Динамические структуры данных. Линейный однонаправленный список с головным элементом».
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Москва,  2010
 
Содержание
 
1.Введение
2.Задача
3.Ход работы
4.Тестирование
5.Заключение
6.Литература
Листинг функциональных частей

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1.Введение
 
В процессе выполнения данной курсовой работы были реализованы  следующие типы динамических структур данных: список (линейный двунаправленный список с головным элементом), объекты и классы; были изучены основные принципы их функционирования. Графическая часть работы реализована с помощью canvas, графические изображения прорисовывались с помощью стандартных функций (типа rectangle, ellipse и т.д.).
              В языке программирования Delphi существует способ выделения памяти под данные, который называется динамическим. В этом случае память под величины отводится во время выполнения программы. Такие величины будем называть динамическими. Раздел оперативной памяти, распределяемый статически, называется статической памятью.
Использование динамических величин предоставляет программисту ряд дополнительных возможностей.
Достоинства динамической памяти:
- экономичность и эффективность ее использования;
- возможность динамического изменения числа элементов в связанных структурах, например, списках (в статической памяти число элементов фиксировано для каждой компиляции);
              - статические переменные существуют только в течение жизни блока, в котором они объявлены, а динамические - и после выхода из блока до окончания программы, а на практике – столько, сколько нужно по  алгоритму;
              - переменная, размещаемая динамически, не объявляется в разделе VAR и не имеет имени в программе («невидимка»). Компилятор не планирует выделение места в памяти под такие переменные.
Наряду  с явными достоинствами стоит также упомянуть про недостатки динамической памяти.
Недостатки динамической памяти:
              - усложняются процессы выделения и освобождения динамической памяти по сравнению со статической;
              - усложняются алгоритмы обработки данных, представленных динамическими структурами.
Работа с динамическими величинами связана с использованием еще одного типа данных — ссылочного типа. Величины, имеющие ссылочный тип, называют указателями.
Указатель содержит адрес поля в динамической памяти, хранящего величину определенного типа. Сам указатель располагается в статической памяти. Физическое представление адреса существенно зависит от аппаратной архитектуры вычислительной системы.
Преимущества динамической памяти становятся особенно очевидными при организации динамических структур, элементы которых связаны через адреса (стеки, очереди, деревья, сети и т.д.). Основой моделирования таких структур являются списки.
Список - это конечное множество динамических элементов, размещающихся в разных областях памяти и объединенных в логически упорядоченную последовательность с помощью специальных указателей (адресов связи).
Список - структура данных, в которой каждый элемент имеет информационное поле (поля) и ссылку (ссылки), то есть адрес (адреса), на другой элемент (элементы) списка.
Порядок расположения информационных и ссылочных полей в элементе при его описании - по выбору программиста, то есть фактически произволен.
Информационная часть в общем случае может быть неоднородной, то есть содержать поля с информацией различных типов.
Ссылки однотипны, но число их может быть различным в зависимости от типа списка.
В связи с этим для описания элемента списка подходит только тип «запись», так как только этот тип данных может иметь разнотипные поля. Например, для однонаправленного списка элемент должен содержать как минимум два поля: одно поле типа «указатель», другое - для хранения данных пользователя. Для двунаправленного - три поля, два из которых должны быть типа «указатель».
Созданием динамических данных должна заниматься сама программа во время своего исполнения. Для этого существует специальная процедура -  New (Current). После выполнения данной процедуры в оперативной памяти ЭВМ создается динамическая переменная, тип которой определяется типом указателя Current. После использования динамического данного и при отсутствии необходимости его дальнейшего использования необходимо освободить оперативную память от этого данного с помощью процедуры – Dispose (Current).
Наиболее простой способ организовать структуру данных, состоящее из некоторого множества элементов – это организовать линейный список. Список называется линейным, если последний элемент списка содержит «нулевую» ссылку, то есть содержит значение предопределенной константы nil и, следовательно, не ссылается ни на какой другой элемент.
При такой организации элементы в списке используют систему указателей, и в зависимости от их количества в элементах различают однонаправленные и двунаправленные линейные списки.
В работе использовался линейный однонаправленный список с головным элементом. В этом списке любой элемент имеет один указатель, который указывает на следующий элемент в списке или является пустым указателем у последнего элемента.
Для доступа к первому элементу списка, а за ним - и к последующим элементам необходимо иметь адрес первого элемента списка. Этот адрес обычно записывается в специальное поле - указатель на первый элемент с именем  first. Если значение first равно nil, это значит, что список пуст, он не содержит ни одного элемента. Список имеет головной элемент (в данном случаи это FIRST), который также имеет ссылочное и информационное поле с информацией о количестве элементов в списке, причем данный элемент при подсчете элементов списка не считается, не участвует в удалении элементов, а удаляется только тогда, когда в списке кроме него нет элементов. 
Как известно, Delphi использует структурный объектно-ориентированный язык. А в основе ООП лежат понятия класса и его физической реализации – объекта.
Класс – это сложная структура (аналогичная типу), включающая в себя, помимо описания данных, описание подпрограмм (процедур и функций), которые могут быть выполнены над объектом, а также характеристики данных и подпрограмм.
Данные класса называются полями, подпрограммы – методами, а характеристики данных и подпрограмм – свойствами.
Обычно классы задаются в разделе объявления типов тех или иных модулей, и, чтобы их можно было использовать в программе и других модулях, эти объявления должны быть сделаны в интерфейсе модуля.
Класс объявляется на основе общего правила задания типов. Описание структуры класса в языке Delphi начинается с зарезервированного слова class, после которого в круглых скобках указывается имя родительского класса. Если он не указан, то предполагается, что родительским является класс TОbjеct, который в ООП-модели языка по умолчанию считается предком всех объявленных классов. Далее в виде отдельных строк записываются поля данных, методы и свойства. Завершается описание класса зарезервированным словом end. Если ни одного поля, метода или свойства у объявляемого класса нет, но указан непосредственный предок класса, зарезервированное слово end в конце объявления можно не писать. Последовательность записи отдельных элементов (поля, методы, свойства) класса безразлична (с учетом возможности использования одними элементами других), однако чаще всего сначала записываются поля, затем методы и, наконец, свойства.
В общем случае синтаксис объявления класса следующий:
 
Туре
имя класса = Class(имя класса-родителя)
public             
              // доступно всем
              <поля, методы, свойства, события>
published             
              // видны и изменяемы в Инспекторе Объектов
              <поля, свойства>
protected             
              // доступ    потомкам
              <поля, методы, свойства, события>
private              // доступ только  в модуле
<поля,   методы,   свойства,   события>
end;
 
Для методов в объявлении класса записываются только их заголовки. Само же тело методов описывается впоследствии - в исполнительной части модуля - так же, как это делается для подпрограмм в модулях.
В ряде случаев может оказаться, что два класса используют характеристики друг друга. В этом случае приходится использовать опережающее объявление одного из этих классов. При опережающем объявлении сначала записывается лишь имя класса и через знак равенства - зарезервированное слово class, например:
TObject = class;
Далее по тексту предварительно объявленный класс должен быть описан полностью в подходящем месте программы так же, как это делается без предварительного объявления.
Отдельные элементы класса могут иметь различные возможности по их использованию вне рассматриваемого класса (иметь разные области доступности или, иначе, видимости). В ООП DELPHI имеется несколько вариантов задания областей видимости, которые определяют разделы (секции) в описании класса и начинаются с ключевых слов private, public, protected, published и automated. Количество и порядок следования этих разделов могут быть произвольными.
В программе представители класса — объекты, объявляются в разделе var. Например, так:
var
stena:TTRoom;
pol:TTRoom;
Следует обратить особое внимание на то, что в Object Pascal объект — динамическая структура. Переменная-объект содержит не данные, а ссылку на данные объекта. Поэтому программист должен позаботиться о выделении памяти для этих данных и задании для них начальных значений.
Выделение памяти и инициализация объекта осуществляются с помощью специального метода класса — конструктора, которому обычно присваивают имя create (создать). Конструктор – это специальный метод, инициализирующий объект, содержащий виртуальные методы.
Конструктор устанавливает связь между экземпляром, который вызывает этот конструктор и таблицей виртуальных методов данного объектного типа. Конструктор должен быть вызван до первого обращения к виртуальному методу. Конструктор может быть использован для инициализации полей данных объектов. Перед вызовом виртуальных методов вызов конструктора обязателен.
Пример реализации конструктора
Constructor TMyClass.Create ( Value : Integer );
Begin
              Inherited Create;
              SomeField := Value ;
End;
 
Реализация конструктора несколько необычна. Во-первых, в теле конструктора нет привычных операторов New, обеспечивающих выделение динамической памяти (всю необходимую работу по выделению памяти выполняет компилятор). Во-вторых, формально конструктор не возвращает значения, хотя в программе обращение к конструктору осуществляется как к методу-функции.
После объявления и инициализации объект можно использовать, например установить значение поля объекта. Доступ к полю объекта осуществляется указанием имени объекта и имени поля, которые отделяются друг от друга точкой. Хотя объект является ссылкой, однако правило доступа к данным с помощью ссылки, согласно которому после имени переменной, являющейся ссылкой, надо ставить значок ^, на объекты не распространяется.
Если в программе некоторый объект больше не используется, то можно освободить память, занимаемую полями этого объекта. Для выполнения этого действия используют метод-деструктор free. Например, чтобы освободить память, занимаемую полями объекта pol, достаточно записать
pol.free;
Под инкапсуляцией понимается скрытие полей объекта с целью обеспечения доступа к ним только посредством методов класса.
В Object Pascal ограничение доступа к полям объекта реализуется с помощью свойств объекта. Свойство объекта характеризуется полем, хранящим значение свойства, и двумя методами, обеспечивающими доступ к полю свойства. Метод установки значения свойства называется методом записи свойства (write), метод получения значения свойства называется методом чтения свойства (read).
В описании класса перед именем свойства записывают ключевое слово property (свойство). После имени свойства указываются его тип, затем имена методов, обеспечивающих доступ к значению свойства. После слова read указывается имя метода, обеспечивающего чтение свойства, после слова write —имя метода, обеспечивающего запись свойства.
Концепция объектно-ориентированного программирования предполагает возможность определять новые классы посредством добавления полей, свойств и методов к уже существующим классам. Такой механизм получения новых классов называется порождением. При этом новый, порожденный, класс (класс-потомок) наследует свойства и методы своего базового, родительского класса. В объявлении класса-потомка указывается класс родителя.
При переопределении методов различают простой и сложный полимор­физм.
Простой полиморфизм используют, если при вызове переопределенно­го метода тип объекта, для которого вызывается этот метод, точно известен, а, следовательно, и точно известно, какой метод должен быть подключен: ме­тод родителя или метод потомка. В этом случае нужный метод определяется на этапе компиляции программы (раннее связывание).
Сложный полиморфизм используют, если при вызове переопределенно­го метода необходимо уточнить, какой метод должен быть подключен: метод родителя или метод потомка, так как объект, для которого вызывается пере­определенный метод, может быть как объектом класса родителя, так и объ­ектом класса потомка. В этом случае нужный метод определяется на этапе выполнения программы (позднее связывание), когда тип объекта точно извес­тен.
Для выявления отношения имеющегося и строящегося классов необхо­димо выполнить анализ структуры объектов предметной области, получен­ных в результате объектной декомпозиции.
Если объекты предметной области слишком сложны, чтобы ставить им в соответствие некий простой класс, то процесс декомпозиции можно про­должить, выделяя внутри сложных объектов более простые.
При этом возможны следующие варианты.
1. Внутри объекта можно выделить объект близкого назначения, но с бо­лее простой структурой и/или поведением - класс для реализации данного объекта следует строить на базе более простого, используя наследование. Ес­ли при этом объекты строящего класса отличаются от объектов базового класса некоторыми аспектами поведения, то следует изменить поведение объектов строящего класса при наследовании, используя полиморфное на­следование с переопределением методов.
2. Внутри объекта можно выделить определенное количество объектов более простой структуры со своим поведением - класс строится объединени­ем объектов других классов с добавлением полей и методов строящегося класса - композиция классов.
3. Внутри объекта можно выделить заранее не предсказуемое количест­во объектов более простой структуры со своим поведением - класс строится с возможностью динамического подключения объектов других классов (на­полнение) и добавлением полей и методов строящегося класса
 
 
2.Задача
 
С помощью языка высокого уровня – «Object Pascal» , спроектировать и создать программный продукт -  игру «Pacman». В программе обязательно должны быть задействованы такие динамические структуры данных: линейный однонаправленный список с головным элементом, объекты.
В игре был определен класс Tghost, впоследствии были созданы три экземпляра данного класса. У объекта есть методы hide (стирает приведение с формы), show (рисует приведение на форме), move (отвечает за смещение приведения) и chdir (отвечает за смену направления движения).
За движение и анимацию объектов отвечают таймеры, которые в заранее определенном интервале запускают методы соответствующих объектов. Экземпляры класса Tghost «охотятся» за pacman-ом, прорисованным на канве, игра заканчивается, когда количество жизней pacman-a равно нулю. Свободное от стен, pacman-a и приведений пространство заполняется «едой» при поедании которой игроку начисляются определенные очки. Новую жизнь pacman получает, когда «съедает» 8 желтых бонусов. На визуальном компоненте StatusBar есть три панелт, в первой отражается количество очков полученных pacman-ом (синий шарик-3 очка, зеленый-2 очка). Количество желтых шариков собранных pacman-ом отражается во второй панели. Когда pacman собирает 8 желтых шариков у него появояется еще одна жизнь. Количество жизней отражается в третьей панели, это число списывается из головного элемента списка.
              Однонаправленным списком с головным элементом в игре является цепь «жизней» pacman-a. Если  pacman собирает 8 желтых шариков, у него появляется жизнь и создается новый элемент списка, который добавляется в конец, если pacman теряет жизнь (попадает на приведение) то элемент удаляется из конца списка. Количество элементов списка, а следовательно и количество жизней, хранится в головном элементе списка.
             
 
 
3.Ход работы
              При запуске игры появляется полностью прорисовывается все элементы игры, которые сразу начинают движение (рис. 1):
 

 
Рис. 1.
 
В любой момент времени игру можно остановить с помощью клавиши «пробел», а продолжить с помощью клавиши «enter».Движение осуществляется с помощью стрелок. Если количество жизней становится равно нулю, игра заканчивается (рис. 2):

 
Рис. 2.
 
 
Если же удалось собрать все шарики, то уровень заканчивается, появлением сообщения «you are win!»   (рис. 3):
 

 
Рис. 3.
 
 
 
 
4.Тестирование
В этом пункте проводится три теста программы и по ним определяется надежность программы.
Тест №1.
Если пакман при движении сталкивается с привидением, должны выполниться действия:
1)                  Количество жизней пакмана должно уменьшится на единицу.
2)                  Если количество жизней равно нулю, игра должна закончится с надписью “Game over” (рис.2).
 
 
 
 
Тест №2.
              При съедании пакманом еды, очки игрока должны увеличиться. При съедании зеленого шарика- на 1 (рис. 4):
 
       
 
Рис. 4.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Тест №3
При съедании синего шарика количество очков должно увеличиться на три (рис.5):
 
        
 
Рис. 5.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Тест №4.
              При съедании пакманом желтого шарика-бонуса, количество бонусов должно отразиться во второй панели StatusBar (рис. 6):
          
 
Рис. 6.
 
Тест №5.
При съедании 8 желтых шариков в третьем поле StatusBar должно увеличиться на 1 количество жизней (рис. 7):
       
 
Рис. 7.
              Все проведенные тесты были выполнены корректно, следовательно, делается вывод – надежность программы равна 100 %.
 
 
 
5.Заключение
Исходные цели были успешно реализованы. Были изучены и успешно реализованы такие структуры данных, как объекты и списки. В задаче используются динамический типы данных, в частности был реализован однонаправленный линейный список с головным элементом, а также освоены основные операции по его редактированию. При создании программы были соблюдены и использованы все основные принципы ООП, а именно наследование, инкапсуляция. В результате мы видим качественный программный продукт «Pacman», успешно прошедший различные тестирования.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6.Литература
Основная:
1.       Delphi 7 Наиболее полное руководство. А. Хомоненко, В. Гофман, Е. Мещеряков, В. Никифоров. — СПб.: БХВ-Петербург 2003.
2.       Фундаментальные алгоритмы и структуры данных в Delphi. Джулиан Бакнелл — СПб.: БХВ-Петербург, 2003.
3.       Фленов М. Е. Библия Delphi. — 2-е изд., перераб. и доп. — СПб.: БХВ-Петербург
4.       Лекции  «Объектная модель Delphi». В.П. Грибанов
Дополнительная:
1.       http://delphiworld.narod.ru – создание объектных переменных.
http://delphiworld.narod.ru/base/create_objective_vars.html
2.       http://delphi-master.ucoz.ru – работа со списками.
http://delphi-master.ucoz.ru/forum/4-10-1

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Листинг функциональных частей
 
 
// Структура класса Tghost
Tghost=class
    public
      coordX:integer;
      coordY:Integer;
      stX:integer;
      stY:integer;
      dir:Char; //direction
      col:Tcolor;
      constructor create;overload;virtual;
      procedure hide;
      procedure show;virtual;
      procedure chdir;
      procedure move;
  end;
 
 
//создание списка
first := new (point);
//FIRST := NIL;
first^.INF1:=0;
FIRST.NEXT := NIL;
k:=0;
 
//добавление элемента в конец списка
PROCEDURE TForm1.INS_END_LIST;
var
  q,p : point;
BEGIN
Q:=FIRST;
WHILE Q.NEXT <> NIL DO
                                                Q:=Q.NEXT;
                                                  Q.NEXT:= new(Point);
                            Q.NEXT.NEXT:=NIL;
               K:=k+1;
               first.inf1:=k;
end;
// удаление элемента из конца списка
PROCEDURE TForm1.DEL_END_LIST;
VAR
Q,P,T:point;
BEGIN
                       IF FIRST <> NIl THEN
           BEGIN
                                                 IF  FIRST.NEXT = NIL THEN
             BEGIN
                                                                           P := FIRST;
                                               DISPOSE (P);
                                                                           FIRST := NIL;
                                                                    END
                                         ELSE    BEGIN
 
                                                                                   Q := FIRST;
                                                                    T := FIRST;
                                         WHILE Q^.NEXT <> NIL DO
                                                                    BEGIN
                                                                            T := Q;
                                                          Q:=Q^.NEXT;
                                                          END;
                                                                    DISPOSE  (Q);
                                                                    T^.NEXT := NIL;
                                                                 END ;
                                      END;
               k:=k-1;
               first.inf1:=k;
END;
 
// движение объекта
procedure TForm1.tmrghostTimer(Sender: TObject);
begin
for i:=0 to 2 do
ghost[i].move;
 
 
procedure Tghost.move;
function can_dvig_vprav: boolean;
var i,j:integer;
 
 
 
begin
 
result:=TRUE;
I:=coordY DIV 30;
J:=coordX DIV 30;
if  ((coordX+d+7)>Form1.clientwidth) or (mas[I+1,j+2]=4) then
begin
result:=FALSE;
end;
end;
 
 
function can_dvig_vlev: boolean;
var i,j:integer;
 
begin
 
result:=TRUE;
I:=coordY DIV 30;
J:=coordX DIV 30;
if  ((coordX-sd)<0) or (mas[I+1,j]=4) then
begin
result:=FALSE;
end;
end;
 
 
function can_dvig_vniz: boolean;
var i,j:integer;
 
begin
 
result:=TRUE;
I:=coordY DIV 30;
J:=coordX DIV 30;
if  ((coordY+d+d-1)> Form1.clientheight) or (mas[I+2,j+1]=4) then
begin
result:=FALSE;
end;
end;
 
 
function can_dvig_vverh: boolean;
var i,j:integer;
 
begin
 
result:=TRUE;
I:=coordY DIV 30;
J:=coordX DIV 30;
if  ((coordY-sd)<0) or (mas[I,j+1]=4) then
begin
result:=FALSE;
end;
end;
begin
   if (dir='R') AND  (can_dvig_vprav) then
 
   begin                             //go right
     hide;
     coordX:=coordX+d;
     show;
 
   end else
 
   if (dir='L') AND  (can_dvig_vlev) then
 
   begin                             //go left
     hide;
     coordX:=coordX-d;
     show;
     // ghost.chdir;
   end else
 
   if (dir='D') AND  (can_dvig_vniz) then
 
   begin                             //go down
     hide;
     coordY:=coordY+d;
     show;
    //  ghost.chdir;
 
   end else
 
   if (dir='U') and (can_dvig_vverh)then
 
   begin                             //go up
     hide;
     coordY:=coordY-d;
     show;
 
   end else
 
   begin
     chdir;
   end;
 
end;
 
 
 
procedure Tghost.hide;
begin
with Form1.image1.canvas do
begin
   pen.Color:=clBlack;
   brush.Color:=clBlack;
   Rectangle(coordX,coordY,coordX+d,coordY+d);
   end;
end;
 
 
procedure Tghost.show;
begin
with Form1.image1.canvas do
begin
   pen.Color:=col;
   brush.Color:=col;
   Rectangle(coordX,coordY,coordX+d,coordY+d);
   end;
end;
 
procedure Tghost.chdir;
var a:integer;
begin
  a:=Random(4);
  case a of
    0:dir:='L';
    1:dir:='R';
    2:dir:='U';
    3:dir:='D';
  end;
end;
 
//создание формы, изначальная прорисовка карты
procedure TForm1.FormCreate(Sender: TObject);
begin
Form1.DoubleBuffered:=True;
with image1.canvas do
begin
 
brush.Color:=clblack;
  fillrect(rect(0,0,clientwidth,clientheight));
  end;
  for i:=1 to 15 do
  for j:=1 to 15 do
  mas[i,j]:=5;
mas[2,2]:=3;
mas[3,2]:=4;
mas[3,3]:=4;
mas[3,4]:=4;
mas[3,5]:=4;
mas[3,6]:=4;
mas[3,9]:=4;
mas[3,10]:=4;
mas[3,11]:=4;
mas[3,12]:=4;
mas[3,13]:=4;
mas[4,9]:=4;
mas[5,9]:=4;
mas[6,9]:=4;
mas[7,9]:=4;
mas[8,9]:=4;
mas[9,9]:=4;
mas[10,9]:=4;
mas[5,4]:=4;
mas[6,4]:=4;
mas[7,4]:=4;
mas[8,4]:=4;
mas[11,3]:=4;
mas[12,3]:=4;
mas[13,3]:=4;
mas[14,3]:=4;
mas[14,4]:=4;
mas[14,5]:=4;
mas[14,6]:=4;
mas[14,7]:=4;
mas[14,8]:=4;
mas[14,9]:=4;
mas[14,10]:=4;
mas[14,11]:=4;
mas[14,12]:=4;
mas[14,13]:=4;
mas[13,13]:=4;
mas[12,13]:=4;
mas[11,13]:=4;
 
for i:=1 to 15 do
for j:=1 to 15 do
  begin
if (mas[i,j]<>4) and (mas[i,j]<>3)
then     mas[i,j]:=random(3);
end;
 
 
for i:=1 to 15 do
for j:=1 to 15 do  begin
if mas[i,j]=4 then
begin
sx:=d*(j-1);
sy:=d*(i-1);
with image1.canvas do
begin
pen.Color:=clcream;
   brush.Color:=clcream;
rectangle(sx,sy,sx+d,Sy+d);
end;
end;
 
 
 
if mas[i,j]=3 then
begin
x1:=d*(j-1);
y1:=d*(i-1);
with image1.canvas do
begin
pen.Color:=clred;
   brush.Color:=clred;
   ellipse(x1,y1,x1+d,y1+d);
   end;
end;
if (mas[i,j]=0)  then
begin
sx:=d*(j-1);
sy:=d*(i-1);
with image1.canvas do
begin
pen.Color:=clgreen;
   brush.Color:=clgreen;
   ellipse(sx+7,sy+7,sx+16,sy+16);
   end;
end;
 
if (mas[i,j]=1)  then
begin
sx:=d*(j-1);
sy:=d*(i-1);
with image1.canvas do
begin
pen.Color:=clblue;
   brush.Color:=clblue;
   ellipse(sx+7,sy+7,sx+16,sy+16);
   end;
end;
 
if (mas[i,j]=2)  then
begin
sx:=d*(j-1);
sy:=d*(i-1);
with image1.canvas do
begin
pen.Color:=clyellow;
   brush.Color:=clyellow;
   ellipse(sx+7,sy+7,sx+16,sy+16);
   end;
end;
 
end;
 
   for i:=0 to 2 do
   ghost[i]:=Tghost.create; //create, draw
   ghost[0].col:=$00EECFF5;
   ghost[1].col:=$00400040;
   ghost[2].col:=clMaroon;
   ghost[0].dir:='L';
   ghost[1].dir:='R';
   ghost[2].dir:='U';
   ghost[0].stX:=3;
   ghost[1].stX:=4;

   ghost[2].stX:=4;

   ghost[0].stY:=3;

   ghost[1].stY:=4;

   ghost[2].stY:=6;

   for i:=0 to 2 do

     begin

       ghost[i].coordX:=ghost[i].stX*d;

       ghost[i].coordY:=ghost[i].stY*d;

     end;

 

    spbonus:=0;

   win:=0;

   bonus:=0;

   timer1.Enabled:=true;

tmrghost.Enabled:=true;

tmrgame.Enabled:=true;

redraw.Enabled:=true;

  tmnaprav.Enabled:=true;

naprav:=#0;

bonus:=0;

sum:=0;

  form1.StatusBar1.panels[1].text:=inttostr(bonus);

  form1.StatusBar1.Panels[0].text:=inttostr(sum);

 

  end;

17

 

 




и т.д.................


Перейти к полному тексту работы


Скачать работу с онлайн повышением уникальности до 90% по antiplagiat.ru, etxt.ru или advego.ru


Смотреть полный текст работы бесплатно


Смотреть похожие работы


* Примечание. Уникальность работы указана на дату публикации, текущее значение может отличаться от указанного.