Рефераты → Остальные рефераты → Ме → Методические указания к курсу программирования для студентов физического факультета Сравнительное объектно-ориентированное проектирование

Методические указания к курсу программирования для студентов физического факультета Сравнительное объектно-ориентированное проектирование

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


Федеральное агентство по образованию


Государственное образовательное учреждение


высшего профессионального образования


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


МЕТОДИЧЕСКИЕ УКАЗАНИЯ


к курсу программирования


для студентов физического факультета


Сравнительное объектно-ориентированное проектирование


Delphi vs C++ vs C#


Часть 2


Ростов-на-Дону


2006


Методические указания разработаны кандидатом физико-математических наук, доцентом кафедры теоретической и вычислительной физики Г.В. Фоминым.


Ответственный редактор доктор физ.-мат. наук, профессор В.П. Саченко


Компьютерный набор и верстка Г.В. Фомин


Печатается в соответствии с решением кафедры теоретической и вычислительной физики физического факультета РГУ, протокол №1 от 17 января 2006 г.


Сравнительное объектно-ориентированное проектирование


Delphi vs C++ vs C#


Часть 2


Содержание настоящего пособия является продолжением его 1-ой части «Сравнительное объектно-ориентированное проектирование Delphi vs C++ vs C#».


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


Спрайты


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


Delphi


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


Интерфейсная секция классов спрайтов

unit uSprite;


{В модуле описаны классы TSpriteList, TSprite и их наследники,


предназначенные для Z-упорядочения графических изображений


на любой канве (например канве объекта типа TPaintBox).


Конструктор класса TSpriteList имеет один параметр -


канву, на которой производится отрисовка.


Конструктор класса TSprite имеет два параметра, определяющие


прямоугольник спрайта и список, которому спрайт принадлежит.}


interface


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


uses Controls,Graphics,Classes,Types;


type


// Предварительное объявление класса TSprite


TSprite=class;


// Тип переменных, содержащих ссылки на классы типа TSprite


TSpriteClass=class of TSprite;


// Список спрайтов


TSpriteList=class


private


// Поля


// Хранит канву ("контекст устройства"), используемую для отображения спрайтов списка


FCanvas:Controls.TControlCanvas;


// Хранит режим отображения графического объекта при его копировании на канву


FCanvasCopyMode:Graphics.TCopyMode;


// Хранит прямоугольник, ограничивающий область отображения спрайтов списка


FClientRect:Types.TRect;


// Хранит список указателей на спрайты


FList:Classes.TList;


// Хранит текущее число спрайтов в списке


FCount:integer;


// Метод


// Возвращает спрайт списка под номером aZ


function GetSprite(aZ:integer):TSprite;


public


// Свойства


// Возвращает спрайт из списка как элемент массива


property Sprites[aZ:integer]:TSprite read GetSprite;default;


// Возвращает текущее число спрайтов в списке


property Count:integer read FCount;


// Возвращает ссылку на список указателей спрайтов


property List:Classes.TList read FList;


// Возвращает ссылку на канву, с которой связаны спрайты списка


property Canvas:Controls.TControlCanvas read FCanvas;


// Возвращает прямоугольник, ограничивающий область изображения спрайтов списка


property ClientRect:Types.TRect read FClientRect;


// Конструктор


// Создает и инициализирует экземпляр списка спрайтов, связанного с данной канвой


constructor Create(const aCanvas:Controls.TControlCanvas);


// Методы


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


procedure BeforeDestruction;override;


// Создает и добавляет в список объект класса aSpriteClass,


// занимающего прямоугольник SpriteRect


function AddSprite(const aSpriteClass:TSpriteClass;


const SpriteRect:Types.TRect):TSprite;


// Перемещает спрайт внутри списка в z-направлении (с одного слоя в другой)


procedure MoveSprite(const fromZ,toZ:integer);


// Удаляет спрайт с индексом aZ (слой) из списка


procedure DeleteSprite(const aZ:integer);virtual;


// Очищает список от указателей на спрайты


procedure Clear;virtual;


end;


// Тип обработчика события, наступающего перед смещением спрайта


OnMoveEvent=function(Sender:TSprite;var NewLocation:Types.TPoint):


Boolean of object;


// Абстрактный класс спрайта регулирует изображение и перемещение спрайта.


// Изображению спрайта на канве предшествует сохранение в памяти фона,


// который перекрывается изображением.


// Требуемый участок фона сохраняется в объекте типа TBitmap.


// Изображение спрайта исчезает в момент восстановления фона –


// обратного копирования на канву сохраненного участка.


TSprite=class(TObject)


private


// Поля


// Хранит состояние видимости спрайта


FVisible: boolean;


// Хранит номер слоя, занимаемого спрайтом


FZ: integer;


// Хранит маску - наличие пересечений с одним из выше лежащих спрайтов


FMask: boolean;


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


FSpriteList: TSpriteList;


// Хранит Bitmap, содержащий фон спрайта


FImage: Graphics.TBitmap;


// Хранит координаты левого верхнего угла спрайта


FLocation: Types.TPoint;


// Хранит размеры спрайта


FSize: Types.TSize;


// Хранит ссылку на обработчик смещения спрайта


FOnMove: OnMoveEvent;


// Методы


// Готовит спрайт к изображению


procedure BeginPaint;


// Завершает процесс изображения спрайта


procedure EndPaint;


// Устанавливает маску для спрайта из слоя aZ


procedure SetMask(const aZ:integer);


// Определяет факт перекрытия спрайтов из слоев First и Second


function Intersect(const First,Second:integer):boolean;


// Устанавливает состояние видимости спрайта


procedure SetVisible(const aVisible: Boolean);


// Возвращает прямоугольник спрайта


function GetSpriteRect:Types.TRect;


// Конструктор


// Создает и инициализирует спрайт, принадлежащий списку Sprites


// с прямоугольником SpriteRect


constructor Create(const SpriteRect: Types.TRect;const Sprites: TSpriteList);


protected


// Методы


// Восстанавливает изображение фона спрайта


procedure Restore;virtual;


// Изображает спрайт


procedure Paint;virtual;


// Формирует реальное изображение спрайта (в этом классе метод абстрактный)


procedure PaintPicture;virtual;abstract;


public


// Свойства


// Возвращает слой спрайта


property Z:integer read FZ;


// Устанавливает и возвращает обработчик при перемещении спрайта


property OnMove:OnMoveEvent read FOnMove write FOnMove;


// Устанавливает и возвращает состояние видимости спрайта


property Visible:Boolean read FVisible write SetVisible;


// Возвращает положение левого верхнего угла спрайта


property Location:Types.TPoint read FLocation;


// Возвращает размеры спрайта


property SpriteSize:Types.TSize read FSize;


// Возвращает прямоугольник спрайта


property SpriteRect:Types.TRect read GetSpriteRect;


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


property SpriteList:TSpriteList read FSpriteList;


// Методы


// Выполняет инициализирующие действия сразу после создания спрайта


procedure AfterConstruction;override;


// Выполняет действия непосредственно перед освобождением спрайта


procedure BeforeDestruction;override;


// Перемещает спрайт на вектор drift


function Move(const drift: Types.TSize): boolean;virtual;


// Перемещает спрайт в новое положение NewLocation


function MoveTo(const NewLocation: Types.TPoint): boolean;virtual;


end;


// Тип массива, хранящего карту следов (пикселей) спрайтов на канве


TTraceMap=Array of array of Boolean;


// Список спрайтов, оставляющих след на канве


TTracedSpriteList=class(TSpriteList)


private


// Поле


// Хранит карту следов на канве


FTraceMap:TTraceMap;


public


//Возвращает карту следов на канве


property TraceMap:TTraceMap read FTraceMap;


// Методы


// Выполняет инициализирующие действия сразу после создания списка


procedure AfterConstruction;override;


// Выполняет действия непосредственно перед освобождением списка


procedure BeforeDestruction;override;


// Удаляет спрайт с индексом aZ (слой) из списка


procedure DeleteSprite(const aZ:integer);override;


// Очищает список от указателей на спрайты


procedure Clear;override;


end;


// Тип массива точек следа спрайта


TTracePoints=array of Types.TPoint;


// Класс, спрайты которого оставляют след перемещения


// по канве списка типа TTracedSpriteList


TTracedSprite=class(TSprite)


private


// Поля


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


FTraced:Boolean;


// Хранит точки со следом


FTracePoints:TTracePoints;


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


FTraceColored:Boolean;


// Хранит цвет следа


FTraceColor:Graphics.TColor;


// Хранит центр спрайта


FCenter:Types.TPoint;


// Метод


// Устанавливает цвет спрайта


procedure SetTraceColor(const aTraceColor:Graphics.TColor);


public


// Свойства


// Возвращает и устанавливает указание на наличия следа


property Traced:Boolean read FTraced write FTraced;


// Возвращает и устанавливает указатель на точки следа


property TracePoints:TTracePoints read FTracePoints;


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


property TraceColored:Boolean read FTraceColored write FTraceColored;


// Возвращает и устанавливает цвет следа


property TraceColor:Graphics.TColor read FTraceColor write SetTraceColor;


// Возвращает центр спрайта


property Center:Types.TPoint read FCenter;


// Методы


// Выполняет инициализирующие действия сразу после создания спрайта


procedure AfterConstruction;override;


// Выполняет действия непосредственно перед освобождением спрайта


procedure BeforeDestruction;override;


// Перемещает спрайт на вектор drift


function Move(const drift:Types.TSize):boolean;override;


// Воспроизводит след


procedure PutTrace;


end;


const DefaultColor=$ffffff;//Цвет эллипса по умолчанию


type


// Класс, изображающий спрайт в форме сплошного эллипса


TEllipseSprite=class(TTracedSprite)


private


// Поле


// Хранит цвет эллипса


FColor:Graphics.TColor;


protected


// Методы


// Изображает эллипс


procedure PaintPicture;override;


// Устанавливает цвет эллипса


procedure SetColor(const aColor:Graphics.TColor);


public


// Свойство


// Возвращает и устанавливает цвет эллипса


property Color:Graphics.TColor read FColor write SetColor;


// Метод


// Выполняет инициализирующие действия сразу после создания спрайта


procedure AfterConstruction;override;


end;


Вспомним правила описания в Delphi в контексте приведенного выше интерфейса модуля uSprite. С этой целью рассмотрим фрагмент начала модуля


uses Controls,Graphics,Classes,Types;


type


// Предварительное объявление класса TSprite


TSprite=class;


// Тип переменных, содержащих ссылки на классы типа TSprite


TSpriteClass=class of TSprite;


// Список спрайтов


TSpriteList=class


// Описание членов класса


…


end;


· Директива uses означает, что в коде настоящего модуля используются типы, переменные, процедуры, функции или константы (короче – имена), описанные в интерфейсах модулей Controls, Graphics, Classes, Types. Все перечисленные модули принадлежат в данном случае библиотеке среды Delphi.


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


· Краткое описание TSprite=class; типа TSprite означает, что класс TSprite будет описан ниже, но упоминание о нем необходимо уже здесь. Дело в том, что описанный ниже класс TSpriteList использует в своем описании TSprite. В то же время полное описание класса TSprite в свою очередь содержит ссылку на класс TSpriteList. Эта взаимозависимость описаний двух классов не позволяет предпочесть в порядке описания один класс другому. Выход – дать краткое (пустое) описание одного из классов перед полным описанием другого.


· Тип TSpriteClass=class of TSprite описывает переменные, которые содержат в себе ссылки на таблицы виртуальных методов класса TSprite и его наследников. Такие переменные могут быть использованы, например, при создании экземпляра объекта, о котором во время программирования известно лишь то, что он принадлежит к семейству спрайтов, то есть является наследником класса TSprite. Так одним из параметров метода AddSprite(const aSpriteClass: TSpriteClass; const SpriteRect: Types.TRect) класса TSpriteList является переменная типа TSpriteClass, указывающая, экземпляр какого класса спрайтов следует добавить в список.


Строка TSpriteList=class открывает описание класса
, которое содержит в себе поля
, свойства
и методы
класса TSpriteList вплоть до служебного слова end, завершающего перечисление членов класса
. Все поля объекта инициализируются при явном вызове конструктора в коде приложения. По умолчанию, если в теле конструктора не указаны другие значения, все поля будут инициализированы нулями.


Каждый член класса TSpriteList имеет определенный уровень доступа
. Так в описании класса TSpriteList имеется две секции, выделенные модификаторами доступа private и public.


Рассмотрим фрагмент кода, описывающий класс TSpriteList:


TSpriteList=class


private


// Поля


// Хранит канву ("контекст устройства"),используемую для отображения спрайтов списка


FCanvas:Controls.TControlCanvas;


…


// Метод


// Возвращает спрайт списка под номером aZ


function GetSprite(aZ:integer):TSprite;


public


// Свойства


// Возвращает ссылку на канву, с которой связаны спрайты списка


property Canvas:Controls.TControlCanvas read FCanvas;


…


// Возвращает спрайт из списка как элемент массива


property Sprites[aZ:integer]:TSprite read GetSprite;default;


// Конструктор


// Создает и инициализирует экземпляр списка спрайтов, связанного с данной канвой


constructor Create(const aCanvas:Controls.TControlCanvas);


…


end;


В Delphi модификатор доступа private применяется к членам класса, которые доступны лишь тому же модулю
, в котором описан сам класс, но недоступны другим модулям программы. Обычно поля класса имеют уровень доступа
private. Члены класса с уровнем доступа public доступны любой части программы
. Свойства класса обычно имеют уровень доступа public. Так поле FCanvas (идентификаторы полей в Delphi принято начинать буквой F от field – поле) имеет уровень доступа private, но свойство Canvas открыто для доступа. Через свойство Canvas можно прочесть поле FCanvas, но нельзя изменить его значение. Так свойства могут регулировать доступ к полям.


Что касается методов, то их разделение по уровням доступа зависит от логики класса. Так, метод GetSprite(aZ:integer):TSprite класса TSpriteList «спрятан» от внешнего доступа под модификатором private. Его роль ограничивается обеспечением доступного свойства Sprites[aZ:integer] возвращаемым значением – спрайтом с индексом aZ из списка. Другие методы класса TSpriteList имеют открытый доступ. Среди них конструктор класса Create, создающий экземпляр объекта и инициализирующий его поля. Параметром конструктора является объект типа TControlCanvas из библиотечного модуля Controls. Объекты этого типа предоставляют спрайтам область изображения - прямоугольник с известными границами в окне приложения и инструменты изображения – кисть и карандаш с цветовой палитрой.


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


Модификатор default в свойстве Sprites указывает на то, что доступ к объектам класса TSpriteList может осуществляться через свойство Sprites как к элементам массива – в индексном виде.


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


Метод


procedure BeforeDestruction; override;


имеет модификатор override. Это означает, что метод BeforeDestruction является виртуальным и унаследован от предка класса TSpriteList, где он описан как виртуальный (virtual). Предком класса TSpriteList является класс TObject.


Другие методы


procedure DeleteSprite(const aZ:integer); virtual;


procedure Clear; virtual;


описаны как виртуальные в самом классе TSpriteList. У наследника TTracedSpriteList, эти же методы преобретают модификатор override.


Рассмотрим еще один фрагмент кода, относящийся к описанию Tsprite и следующий за описанием класса TSpriteList.


// Тип обработчика события, наступающего перед смещением спрайта


OnMoveEvent=function(Sender:TSprite;var NewLocation:Types.TPoint):Boolean of object;


// Абстрактный класс спрайта, регулирующий изображение и перемещение спрайта


TSprite=class(TObject)


private


…


// Конструктор


// Создает и инициализирует спрайт, принадлежащий списку Sprites


// с прямоугольником SpriteRect


constructor Create(const SpriteRect:Types.TRect;const Sprites:TSpriteList);


protected


…


// Формирует реальное изображение спрайта (в этом классе метод абстрактный)


procedure PaintPicture;virtual;abstract;


public


…


end;


Здесь


· Тип функции OnMoveEvent, описанный с модификатором of object, означает, что это тип метода класса
, а не просто тип какой-то отдельной функции. Разница в том, что метод класса обязательно имеет один скрытый параметр Self - экземпляр класса, который его вызывает. У обычных процедур и функций такого параметра нет. Обработчики событий
в Delphi обычно имеют тип метода
. Тогда в них можно подставить ссылку на метод либо формы приложения, либо другого класса, использующего объявленное событие в своих целях.


· В заголовке описания класса TSprite в скобках указан предок TObject, хотя такое указание отсутствует в описании класса TSpriteList. В Delphi отсутствие предка по умолчанию означает, что предком является класс TObject. Так что в описании класса TSprite ссылку на TObject можно также опустить.


· Конструктор класса TSprite помещен в раздел private. Это делает невозможным создание экземпляров отдельных спрайтов из кода, написанного вне модуля uSprite. Логика классов TSprite и TSpriteList предполагает, что созданием спрайтов занимается только метод Add класса TSpriteList, который только и вызывает конструктор экземпляров класса TSprite.


· В описании класса TSprite присутствуют методы с уровнем доступа protected. Эти методы и вообще члены класса с доступом protected доступны любому предку класса TSprite, даже если они описаны в других модулях, но не доступны коду других классов, описанных в других модулях.


· Среди методов класса TSprite, защищенных модификатором protected есть абстрактный метод procedure PaintPicture; virtual; abstract. Он отмечен модификатором abstract. Абстрактный метод PaintPicture не имеет реализации в классе TSprite. Его реализация будет предложена наследниками. Наличие абстрактного метода делает сам класс TSprite абстрактным в том смысле, что его экземпляры не могут быть созданы.


После описания класса TSprite описаны один тип динамического массива


// Тип массива, хранящего карту следов (пикселей) спрайтов на канве


TTraceMap=Array of array of Boolean;


Тип TTraceMap описывает двумерный массив логических значений.


Динамичность массива в том, что его размер не фиксируется как постоянная величина в процессе разработки класса (design time), а определяется лишь в ходе счета (run time). Конкретные переменные, например, размеры области изображения спрайтов, приобретают реальные значения при создании экземпляра класса TTracedSpriteList=class(TSpriteList). Это происходит в методе AfterConstruction класса TTracedSpriteList, выполняющемся сразу вслед за созданием экземпляра объекта этого класса.


За описанием класса TTracedSpriteList и перед описанием класса TtracedSprite есть описание другого типа динамического массива


// Тип массива точек следа спрайта


TTracePoints=array of Types.TPoint;


Это уже одномерный массив точек - записей типа TPoint, описанных в стандартном модуле Types.


Вслед за этим описан класс


TTracedSprite=class(TSprite)


наследник класса TSprite.


Обратите внимание, что класс TTracedSprite, как и его предок TSprite, является абстрактным классом, так как не реализует абстрактный метод PaintPicture.


Вслед за описанием класса TTracedSprite расположен текст


const DefaultColor=$ffffff; //Цвет эллипса по умолчанию


type


// Класс, изображающий спрайт в форме сплошного эллипса


TEllipseSprite=class(TTracedSprite)


Здесь


· Служебное слово const указывает на то, что DefaultColor является постоянной величиной. Значение DefaultColor записано в 16-ной системе счисления, которая удобна при записи цветов. (В данном случае $ffffff означает максимальное число, содержащееся в трех байтах; в десятичной системе это число равно 224
– 1 = 1677215.) Дело в том, что информация о цвете в Delphi представляется четырехбайтовым целым числом. Старший байт используется для системных цветов, а в трех младших байтах находятся стандартные цвета – в младшем красный, в среднем зеленый и в старшем байте - синий. Другими словами чисто зеленый цвет, к примеру, отвечает числу $ff00. В 16-ричной записи видна структура байтов. Каждому байту отводится по две 16-ричные цифры. В данном случае число $ffffff означает, что все составляющие цвета входят одинаково и с полной интенсивностью – это белый цвет.


· Вслед за описанием постоянной идет описание класса TEllipseSprite, поэтому набирается служебное слово type, действие которого было отменено const.


· Класс TEllipseSprite является наследником класса TTracedSprite. В классе TEllipseSprite уже реализован абстрактный метод PaintPicture, поэтому можно создавать его экземпляры – сплошные эллипсовидые спрайты заданного цвета.


Секция реализации

В этой секции модуля находится код методов пяти классов, описанных выше


implementation uses SysUtils;


//Определяет, находится ли прямоугольник source внутри прямоугольника dest


function Contains(const source,dest:Types.TRect):Boolean;


begin


with dest do


Result:=(source.Left>=Left) and (source.Top>=Top)


and (source.Right<=Right) and (source.Bottom<=Bottom);


end {Contains};


//Реализация методов класса TSpriteList


constructor TSpriteList.Create(const aCanvas:Controls.TControlCanvas);


begin


inherited Create;


if Assigned(aCanvas) then FCanvas:=aCanvas else


raise SysUtils.Exception.Create('Конструктору класса TSpriteList не передана канва!');


FClientRect:=FCanvas.Control.ClientRect;


FCanvasCopyMode:=FCanvas.CopyMode;


FList:=Classes.TList.Create;


end {TSpriteList.Create};


procedure TSpriteList.BeforeDestruction;


begin


Clear;


FCanvas.CopyMode:=FCanvasCopyMode;


FList.Free;


FCount:=0;


inherited


end {TSpriteList.BeforeDestruction};


function TSpriteList.GetSprite(aZ:integer):TSprite;


begin


Result:=TSprite(FList[aZ]);


end {GetSprite};


function TSpriteList.AddSprite(const aSpriteClass:TSpriteClass;


const SpriteRect:Types.TRect):TSprite;


var aSprite:TSprite;


begin


Result:=nil;


if Assigned(aSpriteClass) and (SpriteRect.Right- SpriteRect.Left>0) and


(SpriteRect.Bottom-SpriteRect.Top>0) and Contains(SpriteRect,ClientRect) then


begin


aSprite:=aSpriteClass.Create(SpriteRect,Self);


aSprite.FZ:=FList.Add(aSprite);


FCount:=FList.Count;


Result:=aSprite;


end


end {AddSprite};


procedure TSpriteList.MoveSprite(const fromZ,toZ:integer);


var i,minZ:integer;


begin


if (fromZ<>toZ) and (fromZ>-1) and (fromZ<FCount) and


(toZ>-1) and (toZ<FCount) then


begin


if fromZ<toZ then minZ:=fromZ else minZ:=toZ;


for i:=FCount-1 downto minZ do


if Self[i].FVisible then Self[i].Restore;


FList.Move(fromZ,toZ);


for i:=minZ to FCount-1 do


begin


Self[i].FZ:=i;


if Self[i].FVisible then Self[i].Paint


end


end


end {MoveSprite};


procedure TSpriteList.DeleteSprite(const aZ:integer);


var i:integer;


begin


if (aZ>-1) and (aZ<FCount) then


begin


for i:= FCount-1 downto aZ do


with Self[i] do


if Visible then Restore;


Self[aZ].Free;


FList[aZ]:=nil;


FList.Delete(aZ);


FCount:=FList.Count;


for i:= aZ to FCount-1 do


with Self[i] do


begin


Dec(FZ);


if Visible then Paint;


end


end


end {TSpriteList.DeleteSprite};


procedure TSpriteList.Clear;


var i:integer;


begin


if Assigned(FList) then


for i:= FCount - 1 downto 0 do DeleteSprite(i);


end {TSpriteList.Clear};


//Реализация методов класса TSprite


constructor TSprite.Create(const SpriteRect:Types.TRect;const Sprites:TSpriteList);


begin


inherited Create;


FZ:=-1;


FSpriteList:=Sprites;


FLocation:=SpriteRect.TopLeft;


with FSize,SpriteRect do


begin


cx:=Right-Left;cy:=Bottom-Top


end;


end {TSprite.Create};


procedure TSprite.AfterConstruction;


begin


inherited;


FImage:=Graphics.TBitmap.Create;


FImage.Height:=FSize.cy;


FImage.Width:=FSize.cx;


end {TSprite.AfterConstruction};


procedure TSprite.BeforeDestruction;


begin


FImage.Free;


inherited


end {TSprite.BeforeDestruction};


procedure TSprite.SetVisible(const aVisible:Boolean);


begin


if aVisible<>FVisible then


begin


if aVisible then


begin


BeginPaint;


Paint;


EndPaint;


end else


begin


BeginPaint;


Restore;


EndPaint;


end;


FVisible:=aVisible


end


end {SetVisible};


function TSprite.Move(const drift:Types.TSize):boolean;


var NewPos:Types.TPoint;VisState:Boolean;


begin


Result:=true

;


NewPos:=Types.Point(FLocation.X+drift.cx,FLocation.Y+drift.cy);


if Assigned(FOnMove) then Result:=FOnMove(Self,NewPos);


Result:=Result and Contains(


Types.Rect(NewPos.X,NewPos.Y,NewPos.X+FSize.cx,NewPos.Y+FSize.cy),


FSpriteList.FClientRect);


if Result then


begin


VisState:=FVisible;


Visible:=false

;


FLocation:=NewPos;


Visible:=VisState


end


end {TSprite.Move};


function TSprite.MoveTo(const NewLocation:Types.TPoint):boolean;


begin


Result:=Move(Types.TSize(


Types.Point(NewLocation.X-FLocation.X,NewLocation.Y-FLocation.Y)))


end {MoveTo};


procedure TSprite.BeginPaint;


var i:integer;


begin


SetMask(FZ);


for i:=FSpriteList.FCount-1 downto FZ+1 do


with FSpriteList[i] do


if FMask and FVisible then Restore;


end {BeginPaint};


procedure TSprite.SetMask(const aZ:integer);


var i:integer;


begin


for i:=aZ+1 to FSpriteList.FCount-1 do


begin


with FSpriteList[i] do


FMask:= Intersect(aZ,i) or FMask;


if FMask then SetMask(i)


end


end {SetMask};


procedure TSprite.EndPaint;


var i:integer;


begin


for i:=FZ+1 to FSpriteList.FCount-1 do


with FSpriteList[i] do


if FMask then


begin


if FVisible then Paint;


FMask:=false


end


end {EndPaint};


procedure TSprite.Paint;


begin


with FSpriteList do


begin


FCanvas.CopyMode:=cmSrcCopy;


with FImage do


Canvas.CopyRect(Types.Rect(0,0,Width,Height),FCanvas,SpriteRect);


end;


PaintPicture


end {Paint};


procedure TSprite.Restore;


begin


with FSpriteList.FCanvas do


begin


CopyMode:= cmSrcCopy;


with FImage do CopyRect(SpriteRect,Canvas,Types.Rect(0,0,Width,Height));


end


end {Restore};


function TSprite.GetSpriteRect:Types.TRect;


begin


with FLocation,FSize do Result:=Types.Rect(X, Y, X+cx,Y+cy)


end {GetSpriteRect};


function TSprite.Intersect(const First,Second:integer):boolean;


var rect:Types.TRect;


begin


with FSpriteList[First] do


Result:=IntersectRect(rect,SpriteRect,FSpriteList[Second].SpriteRect);


end {Intersect};


//Реализация методов класса TTracedSpriteList


procedure TTracedSpriteList.AfterConstruction;


begin


inherited;


with ClientRect do SetLength(FTraceMap,Right-Left+1,Bottom-Top+1);


end {TTracedSpriteList.AfterConstruction};


procedure TTracedSpriteList.BeforeDestruction;


begin


inherited;


FTraceMap:=nil;


end {TTracedSpriteList.BeforeDestruction};


procedure TTracedSpriteList.DeleteSprite(const aZ:integer);


begin


if (aZ > -1) and (aZ < Count) then


begin


TTracedSprite(Self[aZ]).FTracePoints:=nil;


inherited DeleteSprite(aZ);


end


end {TTracedSpriteList.DeleteSprite};


procedure TTracedSpriteList.Clear;


var i,j:integer;


begin


for i:= Low(FTraceMap) to High(FTraceMap) do


for j:= Low(FTraceMap[i]) to High(FTraceMap[i]) do


FTraceMap[i,j]:= false

;


inherited Clear;


end {TTracedSpriteList.Clear};


//Реализация методов класса TTracedSprite


procedure TTracedSprite.AfterConstruction;


begin


inherited;


FCenter:=Types.CenterPoint(SpriteRect);


end {TTracedSprite.AfterConstruction};


procedure TTracedSprite.BeforeDestruction;


begin


FTracePoints:=nil;


inherited


end {TTracedSprite.BeforeDestruction};


procedure TTracedSprite.SetTraceColor(const aTraceColor:Graphics.TColor);


begin


FTraceColor:=aTraceColor;


FTraceColored:=true


end {SetTraceColor};


function TTracedSprite.Move(const drift:Types.TSize):Boolean;


begin


if FVisible and FTraced then PutTrace;


Result:=inherited Move(drift);


if Result then


FCenter:=Types.CenterPoint(SpriteRect)


end {TTracedSprite.Move};


procedure TTracedSprite.PutTrace;


var i:integer;


begin


with FCenter do


begin


for i:=FSpriteList.FCount-1 downto 0 do


begin


with FSpriteList[i] do


if FVisible and Types.PtInRect(SpriteRect,Self.FCenter)


then Restore;


end;


with TTracedSpriteList(FSpriteList),FClientRect do


if not TraceMap[x-Left,y-Top] then


begin


with FCanvas do


if FTraceColored then Pixels[x,y]:=FTraceColor else


Pixels[x,y]:=$ffffff xor Pixels[x,y];


TraceMap[x-Left,y-Top]:=true

;


SetLength(FTracePoints,High(FTracePoints)+2);


FTracePoints[High(FTracePoints)].X:=x;FTracePoints[High(FTracePoints)].Y:=y;


end;


for i:=0 to FSpriteList.FCount-1 do


begin


with FSpriteList[i] do


if FVisible and Types.PtInRect(SpriteRect,Self.FCenter)


then Paint;


end


end


end {PutTrace};


//Реализация методов класса TEllipseSprite


procedure TEllipseSprite.AfterConstruction;


begin


inherited;


FColor:=DefaultColor;


end {TEllipseSprite.AfterConstruction};


procedure TEllipseSprite.SetColor(const aColor: Graphics.TColor);


var VisState:Boolean;


begin


if FColor<>aColor then


begin


VisState:=FVisible;


Visible:=false

;


FColor:=aColor;


if VisState then Visible:=true


end


end {SetColor};


procedure TEllipseSprite.PaintPicture;


begin


with FSpriteList.FCanvas do


begin


Brush.Style:=bsSolid;


Brush.Color:=Color;


Pen.Color:=color;


Ellipse(SpriteRect);


end;


end {PaintPicture};


end {uSprite}.


Следует отметить, что в Delphi в разделе реализации можно указывать лишь имена методов, не повторяя список параметров и тип функции. Например, вместо строки кода


function TTracedSprite.Move(const drift: Types.TSize): Boolean;


можно было бы записать ее краткий вариант


function TTracedSprite.Move;


Здесь мы этим не пользовались, чтобы не затруднять чтение кода.


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


C++


Теперь рассмотрим версию тех же классов спрайтов, написанную на языке C++ в среде C++ Builder (6-ая версия) фирмы Borland.


Структура программного модуля в C++ несколько отличается от структуры модуля, написанного на Object Pascal в Delphi. В некотором смысле интерфейсной секции дельфийского модуля соответствует отдельный физический файл программного модуля на C++, именуемый «хэдер», или файл заголовков. Хэдер имеет расширение .h. Хэдер все же отличается от дельфийской секции interface тем, что в него можно помещать содержательную часть кода, а не только заголовки. Смотрите, к примеру, функцию Contains, описанную в хэдере.


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


Хэдер

В начале рассмотрим подробнее содержание хэдера классов спрайтов модуля uSprite.


#ifndef uSpriteH


#define uSpriteH


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


/*Модуль, в котором описаны классы TSpriteList и TSprite


для Z-упорядочения графических изображений


на любой канве (например, канве объекта типа TPaintBox).


Конструктор класса TSpriteList имеет один параметр - канву,


на которой производится отрисовка.


Конструктор класса TSprite имеет также один параметр - прямоугольник спрайта.


Объекты типа TSprite помещаются в список


методом AddSprite класса TSpriteList*/


class

TSprite;


//TSpriteList


class

TSpriteList


{


private

:


// Поля


int

count;


TControlCanvas* canvas;


TRect clientRect;


TList* list;


TCopyMode canvasCopyMode;


// Метод


TSprite* __fastcall

GetItems(int

);


public

:


// Свойства


__property

int

Count={read=count};


__property

TControlCanvas* Canvas={read=canvas};


__property

TRect ClientRect={read=clientRect};


__property

TList* List={read=list};


__property

TSprite* Items[int

Index]={read=GetItems};


// Конструктор


__fastcall

TSpriteList(TControlCanvas* const

);


// Деструктор


__fastcall

virtual

~TSpriteList();


// Методы


TSprite* __fastcall

AddSprite(TSprite* const

);


void

__fastcall

MoveSprite(int

const

, int

const

);


void

__fastcall

virtual

DeleteSprite(int

const

);


void

__fastcall

virtual

Clear();


};


// Тип массива следов спрайтов на канве


typedef

DynamicArray< DynamicArray < bool

> > TTraceMap;


//TTracedSpriteList


class

TTracedSpriteList:public

TSpriteList


{


private

:


// Поле


TTraceMap traceMap;


public

:


// Свойство


__property

TTraceMap TraceMap = {read=traceMap};


// Конструктор


__fastcall

TTracedSpriteList(TControlCanvas* const

);


// Деструктор


__fastcall

~TTracedSpriteList();


// Методы


void

__fastcall

virtual

DeleteSprite(int

const

);


void

__fastcall

virtual

Clear();


};


typedef

bool

__fastcall

(__closure

*OnMoveEvent)(TSprite* ,TPoint&);


//TSprite


class

TSprite:public

TObject


{


// Класс TSpriteList, объявленный friend

, получает доступ


// к private

и protected

членам класса TSprite


friend

class

TSpriteList;


private

:


// Поля


bool

visible;


int

z;


TSpriteList* spriteList;


OnMoveEvent onMove;


TSize size;


TPoint location;


Graphics::TBitmap* image;


bool

mask;


// Методы


void

__fastcall

SetVisible(bool

const

);


TRect __fastcall

GetSpriteRect();


void

__fastcall

BeginPaint();


void

__fastcall

EndPaint();


void

__fastcall

SetMask(int

const

);


bool

__fastcall

Intersect(int

const

,int

const

);


protected

:


// Методы


void

__fastcall

virtual

PaintPicture()=0;


void

__fastcall

virtual

Restore();


void

__fastcall

virtual

Paint();


public

:


// Свойства


__property

bool

Visible={read=visible,write=SetVisible};


__property

int

Z={read=z};


__property

TSpriteList* SpriteList={read=spriteList};


__property

OnMoveEvent OnMove={read=onMove,write=onMove};


__property

TSize Size={read=size};


__property

TPoint Location={read=location};


__property

TRect SpriteRect={read=GetSpriteRect};


// Конструктор


__fastcall

TSprite(TRect const

);


// Деструктор


__fastcall

virtual

~TSprite();


// Методы


bool

__fastcall

virtual

Move(TSize const

);


bool

__fastcall

virtual

MoveTo(TPoint const

);


};


// Тип динамического массива точек со следами спрайта


typedef

DynamicArray <TPoint> TTracePoints;


//TTracedSprite


class

TTracedSprite:public

TSprite


{


private

:


// Поля


TTracePoints trPoints;


bool

traced;


bool

traceColored;


TColor traceColor;


TPoint center;


// Метод


void

__fastcall

SetTraceColor(TColor const

);


public

:


// Свойство


__property

TTracePoints TrPoints={read=trPoints};


__property

bool

Traced={read=traced,write=traced};


__property

TColor TraceColor={read=traceColor,write=SetTraceColor};


__property

bool

TraceColored={read=traceColored,write=traceColored};


__property

TPoint Center={read=center};


// Конструктор


__fastcall

TTracedSprite(TRect const

);


// Деструктор


__fastcall

~TTracedSprite();


// Методы


bool

__fastcall

virtual

Move(TSize const

);


void

__fastcall

PutTrace();


};


const

TColor DefaultColor=0xffffff;


//TEllipseSprite


class

TEllipseSprite:public

TTracedSprite


{


private

:


// Поле


TColor color;


protected

:


// Методы


void

__fastcall

virtual

PaintPicture();


void

__fastcall

SetColor(TColor const

);


public

:


// Свойство


__property

TColor Color={read=color, write=SetColor};


// Конструктор


__fastcall

TEllipseSprite(TRect const

);


};


bool

Contains(TRect const

source,TRect const

dest)


{


return

source.Left>=dest.Left && source.Top>=dest.Top &&


source.Right<=dest.Right && source.Bottom<=dest.Bottom;


}


#endif


Весь код хэдера заключен «в скобки» защитного блокиратора
вида


#ifndef uSpriteH


#define uSpriteH


…


#endif


Это директивы компилятору
, которые переводятся так


#ifndef uSpriteH – если не определен символ uSpriteH


#define uSpriteH – определи символ uSpriteH


#endif – заверши область действия директивы «если».


Таким образом, если перед началом компиляции модуля символ uSpriteH определен
, то все, что находится дальше вплоть до директивы #endif , то есть все операторы модуля, компилироваться не будут
. Символ uSpriteH определяется при первой компиляции, когда он еще не
определен, поэтому все повторные компиляции модуля блокируются
.


Рассмотрим отдельные фрагменты кода.


class

TSprite;


//TSpriteList


class

TSpriteList


{


private

:


// Поля


int

count;


TControlCanvas* canvas;


…


void

__fastcall

SetVisible(bool

const

);


TRect __fastcall

GetSpriteRect();


…


__property

int

Count = {read=count};


…


__property

TSprite* Items[int

Index]={read=GetItems};


// Конструктор


__fastcall

TSpriteList(TControlCanvas* const

);


// Деструктор


__fastcall

virtual

~TSpriteList();


TSprite* __fastcall

AddSprite(TSprite* const

);


…


}


Здесь


· В описании типов и переменных на языке C в начале указывается идентификатор типа или тип, а затем имя типа или переменной: class

TSpriteList или int

count.


· Описание членов класса заключается в фигурные скобки. Эти скобки в C играют также роль ограничителей begin, end в Delphi.


· В описании TControlCanvas* canvas; стоит звездочка *. Это описание в языке С означает, что поле canvas является ссылкой на объект
класса TControlCanvas, т.е. просто целым числом, содержащим адрес объекта в памяти. Если звездочку опустить, то canvas будет описана как объект типа TControlCanvas «по значению
», т.е. содержать в себе все поля объекта типа TControlCanvas. В языке C описание объекта по значению приводит к тому, что в месте описания происходит создание реального экземпляра объекта – вызывается его «конструктор по умолчанию» и все поля инициализируются.


· В языке C нет процедур, как в Delphi, - только функции. Те функции, которые не возвращают значений, имеют тип void

. Они являются аналогами процедур в Delphi.


· В C++ Builder в описании всех методов классов участвует модификатор __fastcall

. Его смысл - обеспечить компиляцию в наиболее быстрый способ вызова метода при выполнении кода.


· В языке C даже, если функция не имеет параметров, в ее описании должны стоять скобки как в GetSpriteRect().


· В отличие от Delphi транслятор с языка C различает прописные и строчные буквы. Поэтому принято давать одинаковые имена полям и соответствующим свойствам, но начинать имена полей со строчной буквы, а свойств – с прописной буквы. Сравните, к примеру, описания поля count и свойства Count.


· Обратите внимание на синтаксис описания свойств в C++ Builder.


· Конструктор в C++ отличается от других методов тем, что его имя совпадает с именем класса и что он не возвращает никакой тип, даже void

.


· Имя деструктора также совпадает с именем класса, но перед именем дается знак отрицания ~. Как и констуктор, деструктор не возвращает какой-либо тип. Кроме того, деструктор не должен иметь параметров. Деструктор часто объявляется виртуальным. В этом случае деструкторы всех наследников автоматически становятся виртуальными.


· В C++ модификатор virtual

у виртуальных методов не заменяется у наследников на override

, а остается virtual

.


· В реализации на C++ у метода AddSprite есть только один параметр – ссылка на объект класса TSprite. Поэтому при обращении к методу AddSprite объект спрайта должен быть уже создан. В C++ нет возможности вызвать конструктор объекта, тип класса которого является переменной, как это делается в Delphi.


· При описании заголовков метода в хэдере языка C можно не указывать явно идентификаторы параметров – достаточно только типы. Так, в заголовке метода AddSprite указан только тип
единственного параметра TSprite* const

. Модификатор const

играет ту же роль, что и в Delphi – параметр, объявленный как const

, - не меняет своего значения внутри функции.


Прокомментируем другой фрагмент кода.


…


// Тип массива следов спрайтов на канве


typedef

DynamicArray< DynamicArray < bool

> > TTraceMap;


//TTracedSpriteList


class

TTracedSpriteList:public

TSpriteList


{


…


};


typedef

bool

__fastcall

(__closure

*OnMoveEvent)(TSprite* ,TPoint&);


//TSprite


class

TSprite:public

TObject


{


// Класс TSpriteList, объявленный friend

, получает доступ


// к private

и protected

членам класса TSprite


friend

class

TSpriteList;


…


protected

:


// Методы


void

__fastcall

virtual

PaintPicture()=0;


…


};


Здесь


· Служебное слово typedef

указывает на описание типа (подобно type в Delphi).


· Типом динамического массива, названного TTraceMap, является выражение DynamicArray< DynamicArray < bool

> >. Оно имеет смысл двумерного массива («массива массивов») переменных логического типа. Имя DynamicArray является именем стандартного шаблона (template), находящегося в библиотеке C++Builder. Это параметризованные
, или полиморфные
(generic) функции. В Delphi нет аналогов шаблонам. Аргументом шаблона является тип. В данном случае аргументом внутреннего шаблона DynamicArray является тип bool

, а аргументом внешнего – сам возвращаемый тип внутреннего шаблона DynamicArray< bool

>.


· Класс TTracedSpriteList является наследником класса TSpriteList. В заголовке описания класса TTracedSpriteList присутствует ссылка на наследник TSpriteList с модификатором public

. Модификатор public

в данном контексте означает, что все члены, наследуемые от TSpriteList, сохраняют свою, заданную предком, доступность и в наследнике (public

остается public

и т.д.). Если бы модификатором был protected

, то все наследуемые члены класса, объявленные в предке с модификаторами public

и protected

, приобрели бы в наследнике модификатор protected

.


· В описании


typedef

bool

__fastcall

(__closure

*OnMoveEvent)(TSprite* ,TPoint&); именем описываемого типа является OnMoveEvent. Сам тип является методом класса
с двумя параметрами типа TSprite* и TPoint&, который возвращает тип bool

. То, что OnMoveEvent именно метод класса, а не просто функция, отмечено модификатором __closure

. Тип TPoint является стандартным и описан в библиотеке C++Builder. Знак & служит для описания «параметра по ссылке» – аналог служебного слова var в Delphi.


· Модификаторы доступа к членам класса в C имеют слегка иной смысл, нежели в Delphi. Все члены с модификатором private

доступны только
методам этого же
класса вне зависимости от того, в каком модуле класс описан. Члены класса с модификатором protected

– только методам своего класса и классов-наследников. В Delphi члены с модификаторами private

и protected

доступны всему коду того модуля, в котором описан класс. Однако в C++ существует способ сделать доступными защищенные (private

и protected

) члены класса другому классу. Для этого класс, методам которого разрешается доступ к защищенным членам, описывается как friend

. Примером является декларация из описываемого кода friend

class

TSpriteList. Она говорит, что классу TSpriteList разрешается доступ ко всем без исключения членам класса TSprite.


· Обратите внимание на синтаксис описания абстрактного метода
в C++ void

__fastcall

virtual

PaintPicture()=0;


Реализация классов спрайтов

Ниже приведен полный код реализации классов спрайтов, описанных в хэдере. Комментарий к коду приводится непосредственно в тексте кода.


#include <vcl.h> //Модуль, несущий определения библиотеки VCL


/*Директива #pragma hdrstop означает окончание списка хэдеров,


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


файлах-исходниках одного проекта. В данном случае в этом списке


есть только файл vcl.h.


Директива #pragma hdrstop автоматически добавляется средой.*/


#pragma hdrstop


#include "uSprite.h" //хэдер нашего исходника


/*Директива #pragma package(smart_init) служит для «разумной»


последовательности в инициализации модулей при формировании


кода проекта. Она также автоматически добавляется средой


при создании нового модуля.*/


#pragma package(smart_init)


/*Далее располагается собственно авторский код.


Любой метод класса должен иметь в заголовке


имя класса, отделенного от имени самого метода


двойным двоеточием. В Delphi это была точка.*/


// Здесь реализуются методы класса TSpriteList.


// Конструктор инициализирует поля класса


__fastcall

TSpriteList::TSpriteList(TControlCanvas* const

canvas)


{


if

(canvas) //Условие оператора if всегда пишется в скобках.


/* Проверку наличия не нулевого указателя можно проводить,


используя просто сам указатель, как в коде.


Это равносильно записи условия в виде (canvas!=NULL) –


указатель canvas не равен
NULL*/


{


// служебное слово this

в C имеет смысл self в Delphi – указатель на вызывающий объект


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


// оператор присвоения в С имеет вид =, а для сравнения используется двойной знак ==


this

->canvas=canvas;


clientRect=canvas->Control->ClientRect;


canvasCopyMode=canvas->CopyMode;


list=new

TList(); // Так создается экземпляр объекта. Здесь TList() – конструктор.


} else


/*Служебное слово throw

используется для создания исключительной ситуации.


После этого нормальный ход про

граммы прерывается.


Управление передается на ближайший блок catch

.*/


throw

Exception("Канва не задана!");


}


// Деструктор очищает список от спрайтов, восстанавливает свойства канвы


// и убирает сам экземпляр списка list


__fastcall

TSpriteList::~TSpriteList()


{


Clear();


canvas->CopyMode=canvasCopyMode;


delete

list; // Так вызывается деструктор объекта.


}


// Возвращает элемент списка спрайтов, отвечающий слою aZ,


// как указатель на объект типа TSprite


TSprite* __fastcall

TSpriteList::GetItems(int

aZ)


{


// служебное слово return

вызывает выход из метода и возвращение значения функции


// выражение (TSprite*) означает преобразование типа
указателя, полученного после


// вызова свойства list->Items[aZ], в указатель на TSprite


return

(TSprite*)list->Items[aZ];


}


// Добавляет в список объект типа TSprite и возвращает указатель на добавленный объект


TSprite* __fastcall

TSpriteList::AddSprite(TSprite* const

sprite)


{


// двойной знак && есть операция логического умножения


if

(sprite && Contains(sprite->SpriteRect,ClientRect))


{


sprite->spriteList=this

;


sprite->z =list->Add(sprite);


count=list->Count;


return

sprite;


} else

return

NULL;


}


// Перемещает спрайт с одной плоскости в другую (в смысле z-упорядочения)


void

__fastcall

TSpriteList::MoveSprite(int

const

fromZ, int

const

toZ)


{


if

(fromZ != toZ && fromZ > -1 && fromZ < count &&


toZ > -1 && toZ < count)


{


//В языке C локальные переменные (как minZ здесь)


// могут быть описаны в любой точке кода


// Выражение вида a = b?c:d называется условным выражением.


// В нем переменной a присваивается значение c, если выполняется условие b,


// и значение d, если оно не выполняется


// int

minZ = fromZ < toZ ? fromZ : toZ;


// В операторе цикла значение i в начале инициализируется,


// затем проверяется условие окончания цикла,


// выполняется оператор внутри цикла (если условие соблюдено),


// затем меняется значение параметра i.


// В данном случае оператор i-- означает уменьшение i на 1.


for

(int

i = count - 1; i >= minZ; i--)


if

(Items[i]->Visible) Items[i]->Restore();


list->Move(fromZ,toZ);


for

(int

i = minZ; i < count; i++)


{


Items[i]->z = i;


if

(Items[i]->Visible) Items[i]->Paint();


}


}


}


// Освобождает экземпляр объекта типа TSprite,


// находящийся в списке под номером aZ, и убирает указатель из списка


void

__fastcall

TSpriteList::DeleteSprite(int

const

aZ)


{


if

(aZ<count && aZ>-1)


{


for

(int

i= count-1;i>=aZ;i--)


if

(Items[i]->Visible) Items[i]->Restore();


delete

Items[aZ];


list->Items[aZ]=NULL;


list->Delete(aZ);


count=list->Count;


for

(int

i=aZ;i<count;i++)


{


Items[i]->z--;


if

(Items[i]->Visible) Items[i]->Paint();


}


}


}


// Очищает список от всех спрайтов


void

__fastcall

TSpriteList::Clear()


{


if

(list && count > 0)


for

(int

i = count - 1; i > -1; i--) DeleteSprite(i);


};


// Реализация методов класса списка спрайтов со следом TTracedSpriteList


// Конструктор вызывает конструктор предка и инициализирует поле traceMap


// После имени конструктора через двоеточие вызывается конструктор предка TSpriteList.


__fastcall

TTracedSpriteList::TTracedSpriteList(TControlCanvas* const

canvas):


TSpriteList(canvas) // Вызов конструктора предка


{


traceMap.Length=ClientRect.Right-ClientRect.Left+1;


for

(int

i=0;i<=traceMap.High;i++)


traceMap[i].Length=ClientRect.Bottom-ClientRect.Top+1;


}


// Деструктор вызывает очистку списка от спрайтов и вызывает деструктор предка


__fastcall

TTracedSpriteList::~TTracedSpriteList()


{


Clear();


}


// Удаляет спрайт слоя aZ из списка и удаляет сам спрайт


void

__fastcall

TTracedSpriteList::DeleteSprite(int

const

aZ)


{


((TTracedSprite*)Items[aZ])->TrPoints.Length=0;


TSpriteList::DeleteSprite(aZ); // Вызывается метод предка


}


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


void

__fastcall

TTracedSpriteList::Clear()


{


for

(int

i=traceMap.Low;i<= traceMap.High;i++)


for

(int

j=traceMap[i].Low;j<traceMap[i].High;j++)


traceMap[i][j]=false

;


TSpriteList::Clear(); // Вызывается метод предка


}


// Реализация методов класса спрайт TSprite


// Конструктор инициализирует поля класса


__fastcall

TSprite::TSprite(TRect const

rect)


{


location=Point(rect.Left,rect.Top);


size.cx=rect.Width(); size.cy=rect.Height();


image=new

Graphics::TBitmap();


image->Height=rect.Height();


image->Width =rect.Width();


z=-1;


}


// Деструктор уничтожает поле image


__fastcall

TSprite::~TSprite()


{


delete

image;


}


// Устанавливает новое значение поля visible и изображает или убирает спрайт с экрана


void

__fastcall

TSprite::SetVisible(bool

const

value)


{


if

(value!=visible)


{


if

(value)


{


BeginPaint();


Paint();


EndPaint();


} else


{


BeginPaint();


Restore();


EndPaint();


}


visible=value;


}


}


// Директива компилятору #define в данном случае вводит имя sprite


// для выражения ((TSprite*)(spriteList->Items[i])).


// Это укорачивает имя кода последующих методов


#define sprite ((TSprite*)(spriteList->Items[i]))


// Перемещает спрайт на вектор drift в плоскости изображения


bool

__fastcall

TSprite::Move(TSize const

drift)


{


TPoint newPos=Point(location.x+drift.cx,location.y+drift.cy);


bool

result=true

;


// В этом месте вызывается обработчик события onMove, если он задан


if

(onMove) result=onMove(this

,newPos);


// Здесь используется то, что оператор присвоения в C возвращает присвоенное значение


// Переменная result приобретает новое значение и одновременно возвращает его как


// условие оператора if


if

(result=result &&


Contains(Rect(newPos.x,newPos.y,newPos.x+size.cx,newPos.y+size.cy),


spriteList->ClientRect))


{


bool

VisState=visible;


Visible=false

;


location=newPos;


Visible=VisState;


}


return

result;


}


// Перемещает спрайт в точку newPos


bool

__fastcall

TSprite::MoveTo(TPoint const

newPos)


{


TSize s;


s.cx=newPos.x-location.x;s.cy=newPos.y-location.y;


return

Move(s);


}


// Готовит изображение спрайта


void

__fastcall

TSprite::BeginPaint()


{


SetMask(Z);


for

(int

i=spriteList->Count-1;i>=Z+1;i--)


if

(sprite->mask && sprite->visible) sprite->Restore();


}


// Устанавливает маску для спрайта с индексом anID (слой)


void

__fastcall

TSprite::SetMask(int

const

anID)


{


for

(int

i=anID+1;i<spriteList->Count;i++)


{


sprite->mask= sprite->Intersect(anID,i) || sprite->mask;


if

(mask) SetMask(i);


}


}


// Завершает изображение спрайта


void

__fastcall

TSprite::EndPaint()


{


for

(int

i=Z+1;i<spriteList->Count;i++)


if

(sprite->mask)


{


if

(sprite->visible) sprite->Paint();


sprite->mask=false

;


}


}


// Директива компилятору #undef отказывается от обозначения sprite


#undef sprite


// Директива компилятору #define в данном случае вводит имя canvas


#define canvas spriteList->Canvas


// Изображает спрайт на канве


void

__fastcall

TSprite::Paint()


{


canvas->CopyMode=cmSrcCopy;


image->Canvas->CopyRect(Rect(0,0,image->Width,image->Height),


canvas, SpriteRect);


PaintPicture();


}


// Убирает изображение спрайта с канвы, восстанавливая фон


void

__fastcall

TSprite::Restore()


{


canvas->CopyMode=cmSrcCopy;


canvas->CopyRect(SpriteRect, image->Canvas,


Rect(0,0,image->Width,image->Height));


}


// Директива компилятору #undef отказывается от обозначения canvas


#undef canvas


// Возвращает прямоугольник спрайта


TRect __fastcall

TSprite::GetSpriteRect()


{


return

Rect(location,Point(location.x+size.cx,location.y+size.cy));


}


// Определяет факт пересечения прямоугольников спрайтов,


// находящихся в слоях First и Second


bool

__fastcall

TSprite::Intersect(int

const

First,int

const

Second)


{


TRect rect;


return

IntersectRect(rect,


((TSprite*)(spriteList->Items[First]))->SpriteRect,


((TSprite*)(spriteList->Items[Second]))->SpriteRect);


}


// Реализация методов класса спрайт со следом TtracedSprite


// Констуктор класса вызывает конструктор предка и инициализирует поле center


__fastcall

TTracedSprite::TTracedSprite(TRect const

rect):TSprite(rect)


{


center = CenterPoint(SpriteRect);


}


// Деструктор освобождает массив точек следа и вызывает деструктор предка


__fastcall

TTracedSprite::~TTracedSprite()


{


trPoints.Length=0;


}


// Устанавливает цвет следа и, одновременно, делает след цветным


void

__fastcall

TTracedSprite::SetTraceColor(TColor const

value)


{


traceColor=value;


traceColored=true

;


}


// Перемещает спрайт на вектор drift


bool

__fastcall

TTracedSprite::Move(TSize const

drift)


{


if

(Visible && Traced) PutTrace();


bool

result=TSprite::Move(drift); // Так вызывается метод наследника


if

(result) center =CenterPoint(SpriteRect);


return

result;


}


#define sprite ((TTracedSprite*)(SpriteList->Items[i]))


#define sprList ((TTracedSpriteList*)SpriteList)


// Помещает пиксел следа на канву


void

__fastcall

TTracedSprite::PutTrace()


{


for

(int

i=SpriteList->Count-1;i>=0;i--)


if

(sprite->Visible && PtInRect(sprite->SpriteRect,Center))


sprite->Restore();


// Знак ! означает оператор логического отрицания в C


if

(!sprList->TraceMap[Center.x-sprList->ClientRect.Left]


[Center.y-sprList->ClientRect.Top])


{


SpriteList->Canvas->Pixels[Center.x][Center.y]=traceColored?traceColor:


// Знак ^ означает оператор логической симметрической разности.


(TColor)(0xffffff ^ SpriteList->Canvas->Pixels[Center.x][Center.y]);


sprList->TraceMap[Center.x-sprList->ClientRect.Left]


[Center.y-sprList->ClientRect.Top]=true

;


trPoints.Length++;


trPoints[trPoints.High].x=Center.x;


trPoints[trPoints.High].y=Center.y;


}


for

(int

i=0;i<SpriteList->Count;i++)


if

(sprite->Visible && PtInRect(sprite->SpriteRect,Center))


sprite->Paint();


}


#undef sprite


#undef sprList


// Реализация методов класса эллиптического спрайта TEllipseSprite


// Констуктор вызывает конструктор предка и инициализирует поле color


__fastcall

TEllipseSprite::TEllipseSprite(TRect const

rect):


TTracedSprite(rect)


{


color=DefaultColor;


}


// Устанавливает цвет спрайта, меняя его изображение на экране


void

__fastcall

TEllipseSprite::SetColor(const

TColor value)


{


if

(color!=value)


{


bool

VisState=Visible;


Visible=false

;


color=value;


if

(VisState) Visible=true

;


}


}


#define canvas SpriteList->Canvas


// Создает изображение эллиптического спрайта на канве


void

__fastcall

TEllipseSprite::PaintPicture()


{


canvas->Brush->Style=bsSolid;


canvas->Brush->Color=color;


canvas->Pen->Color=color;


canvas->Ellipse(SpriteRect);


};


#undef canvas


Предлагается создать оконное приложение, тестирующее описанные классы спрайтов, в среде C++ Builder.


C#


В языке C# компилируемый модуль
является отдельным файлом и содержит в себе сразу и описание, и реализацию методов класса. Хэдеры отсутствуют. Последовательность описания членов класса не имеет значения. Более того, такой модуль легко скомпилировать в форме отдельного исполняемого модуля
с расширением .dll (dynamic link library). В отличие от exe-файла динамически загружаемая библиотека не имеет точки входа и не может выполняться независимо от вызывающего приложения.


В языке C# все типы являются классами – наследниками одного общего для всех класса Object. Это относится даже к простым типам int

, double и т.д. Такие типы являются типами
-значениями
. К типам-значениям относится также перечислимый тип enum. Объекты типов-значений передаются целиком со всеми своими полями. Обычно это небольшие по объему структуры
(struct). Другие типы классов передаются по ссылке (указателю, или адресу) и называются ссылочными типами
. К ним относятся многие библиотечные и пользовательские классы (class

).


В C# cуществует специфический тип классов, обозначаемый служебным словом delegate

. Тип delegate

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


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


Весь код в C# разбит на пространства имен
(namespace

). Часто отдельный компилируемый модуль относится к одному пространству имен, которое указывается в заголовке модуля (в нашем случае это namespace

spritesdll). Но это не правило.


В общем случае


· один исполняемый модуль (.dll или .exe) может собираться из нескольких компилируемых модулей, образуя «сборку» (assembly);


· один компилируемый модуль может состоять из нескольких пространств имен;


· одно пространство имен может охватывать несколько компилируемых модулей;


· описание одного класса может охватывать несколько компилируемых модулей, но при этом каждый отдельный класс может принадлежать только одному пространству имен.


Далее весь комментарий находится в тексте.


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


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

.


Если имя пространства имен (например, в нашем случае, имя System.Collections)


присутствует в списке, то в коде модуля имя любого идентификатора из пространства


имен System.Collections (в нашем случае имя типа ArrayList) может быть записано


сокращенно (ArrayList) – без указания имени пространства имен


(т.е., не в виде System.Collections.ArrayList).*/


using

System;


using

System.Collections;


using

System.Drawing;


using

System.Drawing.Drawing2D;


using

System.Windows.Forms;


namespace

spritesdll


{


// Следующий ниже и далее в тексте комментарий, выделенный тройным слэшом ///,


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


/// <summary>


/// Поддерживает список спрайтов, используя объект типа ArrayList.


/// </summary>


/// <remarks>


/// Спрайт - плоский графический объект, занимающий прямоугольную область экрана.


/// Каждый спрайт списка принадлежит как-бы отдельной


/// изображающей плоскости экрана - z-слою.


/// Каждый спрайт списка имеет свое значение z - индекс спрайта в списке.


/// Ось z направлена перпендикулярно экрану по направлению к наблюдателю.


/// Единственным параметром конструктора класса SpriteList является


/// объект типа Control.


/// Объект Control ограничивает область перемещения спрайтов списка и


/// создает объект класса Graphics для изображения спрайта.


/// При перерисовке объекта Control или его уничтожении список очищается.


/// Каждый спрайт списка создается методом Add, параметрами которого являются


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


/// Метод Add возвращает экземпляр созданного спрайта.


/// Прямоугольник спрайта должен полностью принадлежать прямоугольнику


/// объекта Control.


/// Списку могут принадлежать спрайты разного типа -


/// наследники абстрактного класса Sprite.


/// Метод RemoveSpriteAt удаляет из списка спрайт, принадлежащий конкретному слою.


/// Метод Clear удаляет все спрайты из списка.


/// Метод MoveSprite перемещает спрайт из одного слоя в другой.


/// Элементы списка доступны через индексы с нулевой базой.


/// </remarks>


public

class

SpriteList


{


/// <summary>


/// Хранит ссылку на объект типа Graphics для изображения спрайтов.


/// </summary>


Graphics canvas;


/// <summary>


/// Возвращает ссылку на объект типа Graphics для изображения спрайтов.


/// </summary>


// Так описываются свойства в C#. Модификатор доступа internal

ограничивает


// доступ к члену класса тем исполняемым модулем, в котором этот член описан.


internal

Graphics Canvas { get

{ return

canvas; } }


/// <summary>


/// Хранит ссылку на Control, с которым связан список спрайтов.


/// </summary>


Control parent;


/// <summary>


/// Возвращает ссылку на Control, ограничивающий спрайты списка.


/// </summary>


internal

Control Parent { get

{ return

parent; } }


/// <summary>


/// Хранит ссылку на клиентский прямоугольник объекта Control.


/// </summary>


Rectangle clientRect;


/// <summary>


/// Возвращает ссылку на клиентский прямоугольник объекта Control.


/// </summary>


public

Rectangle ClientRect { get

{ return

clientRect; } }


/// <summary>


/// Хранит ссылку на список ссылок на спрайты.


/// </summary>


// ArrayList – стандартный класс, описанный в одной из библиотек .net.


ArrayList list = new

ArrayList();


/// <summary>


/// Возвращает ссылку на список ссылок на спрайты.


/// </summary>


internal

ArrayList List { get

{ return

list; } }


/// <summary>


/// Возвращает спрайт - элемент списка из данного слоя.


/// </summary>


/// <param name="z">


/// Слой-индекс спрайта в списке.


/// </param>


/// <returns>


/// Спрайт из слоя z.


/// </returns>


// Так описывается свойство, индексирующее объекты класса – так называемый индексатор


public

Sprite this

[int

z] { get

{ return

(Sprite)list[z]; } }


/// <summary>


/// Хранит текущее число спрайтов в списке.


/// </summary>


int

count;


/// <summary>


/// Возвращает число спрайтов в списке.


/// </summary>


public

int

Count { get

{ return

count; } }


/// <summary>


/// Инициализирует новый экземпляр объекта класса типа SpriteList.


/// </summary>


/// <param name="control">


/// Объект типа Control, на прямоугольнике которого предполагается размещать


/// спрайты - элементы списка SpriteList.


/// </param>


/// <remarks>


/// Конструктор списка создает объект типа Graphics для изображения спрайтов


/// и добавляет к событиям перерисовки и уничтожения объекта Control


/// вызов метода Clear


/// </remarks>


public

SpriteList(Control control)


{


if

(control == null

) throw

(


new

ArgumentNullException("Аргумент конструктора SpriteList не определен!"));


parent = control;


canvas = parent.CreateGraphics();


clientRect = parent.ClientRectangle;


parent.HandleDestroyed += delegate

{ Clear(); };


parent.Invalidated += delegate

{ Clear(); };


}


/// <summary>


/// Возвращает перечислитель, позволяющий перемещаться по списку.


/// </summary>


/// <returns>


/// Ссылка на объект типа IEnumerator для списка SpriteList.


/// </returns>


/// <remarks>


/// Функция GetEnumerator позволяет использовать оператор foreach


/// для членов списка (спрайтов).


/// </remarks>


public

IEnumerator GetEnumerator() { return

list.GetEnumerator(); }


/// <summary>


/// Очищает список и освобождает объект типа Graphics,


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


/// </summary>


~SpriteList()


{


Clear();


if

(canvas != null

) canvas.Dispose();


}


/// <summary>


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


/// </summary>


/// <param name="SpriteType">


/// Имя класса добавляемого спрайта.


/// </param>


/// <param name="SpriteRect">


/// Прямоугольник спрайта.


/// </param>


/// <returns>


/// Созданный и добавленный в список спрайт.


/// </returns>


/// <remarks>


/// Метод Add возвращает null

, если прямоугольник спрайта не


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


/// </remarks>


public

Sprite AddSprite(Type SpriteType, Rectangle SpriteRect)


{


if

(SpriteType != null

&& SpriteRect != null


&& SpriteRect.Height > 0 && SpriteRect.Width > 0 &&


clientRect.Contains(SpriteRect))


{


Sprite sprite;


try


{


sprite = (Sprite)Activator.CreateInstance(SpriteType,


new

object

[2] { SpriteRect, this

});


}


catch

(Exception e)


{


throw

(e is

System.Reflection.TargetInvocationException ?


e.InnerException : e);


}


sprite.Z = list.Add(sprite);


count = list.Count;


return

sprite;


}


return

null

;


}


/// <summary>


/// Меняет z-слой положения спрайта.


/// </summary>


/// <param name="fromZ">


/// Исходный слой.


/// </param>


/// <param name="toZ">


/// Конечный слой.


/// </param>


public

void

MoveSprite(int

fromZ, int

toZ)


{


if

(fromZ != toZ &&


fromZ > -1 && fromZ < count &&


toZ > -1 && toZ < count)


{


Sprite tempSprite;


int

minZ = fromZ < toZ ? fromZ : toZ;


for

(int

i = count - 1; i >= minZ; i--)


if

(this

[i].Visible) this

[i].Restore();


tempSprite = this

[fromZ];


list.RemoveAt(fromZ);


list.Insert(toZ, tempSprite);


for

(int

i = minZ; i < count; i++)


{


this

[i].Z = i;


if

(this

[i].Visible) this

[i].Paint();


}


}


}


/// <summary>


/// Удаляет спрайт заданного слоя из списка.


/// </summary>


/// <param name="z">


/// Слой удаляемого спрайта.


/// </param>


public

virtual

void

RemoveSpriteAt(int

z)


{


if

(z > -1 && z < count)


{


for

(int

i = count - 1; i >= z; i--)


if

(this

[i].Visible) this

[i].Restore();


list.RemoveAt(z);


count = list.Count;


for

(int

i = z; i < count; i++)


{


this

[i].Z--;


if

(this

[i].Visible) this

[i].Paint();


}


}


}


/// <summary>


/// Очищает список от спрайтов.


/// </summary>


public

virtual

void

Clear()


{


if

(list != null

&& count > 0)


for

(int

i = count - 1; i > -1; i--) RemoveSpriteAt(i);


}


}


/// <summary>


/// Тип делегата, предназначенного для обработки события,


/// наступающего в методе Move перед перемещением спрайта.


/// </summary>


/// <param name="sender">


/// Экземпляр наследника класса Sprite, вызывающий обработчик.


/// <param name="newLocation">


/// Новое положение левой верхней вершины спрайта,


/// которое может быть изменено обработчиком.


/// </param>


/// <returns>


/// true

, если перемещение в новое положение разрешено, и false

в противном случае.


/// </returns>


public

delegate

bool

BeforeMoveEventHandler(Sprite sender, ref

Point newLocation);


/// <summary>


/// Абстрактный класс спрайтов.


/// </summary>


/// <remarks>


/// Спрайт - это графический объект, ограниченный прямоугольной областью.


/// Объекты наследников класса Sprite создаются методом AddSprite класса SpriteList.


/// Изображения спрайтов могут независимо перемещаться на экране,


/// как бы занимая каждый свой слой (z-упорядочение).


/// Для перемещения спрайтов служат методы Move и MoveTo.


/// Свойство Visible определяет присутствие спрайта на экране.


/// </remarks>


public

abstract

class

Sprite : Object


{


/// <summary>


/// Инициализирует экземпляр объекта класса Sprite.


/// Вызывается в методе AddSprite класса SpriteList.


/// </summary>


/// <param name="SpriteRect">


/// Прямоугольник спрайта.


/// <param name="sprites">


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


/// </param>


/// <remarks>


/// Конструктор инициализирует поля объекта.


/// </remarks>


internal

Sprite(Rectangle SpriteRect, SpriteList sprites)


{


spriteSize = SpriteRect.Size;


location = SpriteRect.Location;


image = new

Bitmap(spriteSize.Width, spriteSize.Height);


bmpCanvas = Graphics.FromImage(image);


this

.sprites = sprites;


}


/// <summary>


/// Деструктор. Освобождает объект image.


/// </summary>


~Sprite()


{


if

(image != null

) image.Dispose();


}


/// <summary>


/// Хранит текущий индекс-слой спрайта.


/// </summary>


int

z = -1;


/// <summary>


/// Возвращает и устанавливает значение индекса-слоя спрайта.


/// </summary>


public

int

Z { get

{ return

z; } internal

set

{ z = value

; } }


/// <summary>


/// Хранит текущее значение маски, используемой при определении фона спрайта.


/// </summary>


bool

mask;


/// <summary>


/// Устанавливает маску спрайта.


/// </summary>


/// <param name="layer">


/// Индекс (слой) спрайта.


/// </param>


void

SetMask(int

layer)


{


for

(int

i = layer + 1; i < sprites.Count; i++)


{


sprites[i].mask = sprites[i].Intersect(layer, i) || sprites[i].mask;


if

(mask) SetMask(i);


}


}


/// <summary>


/// Хранит ссылку на объект класса Bitmap,


/// временно хранящего фон спрайта.


/// </summary>


Bitmap image;


/// <summary>


/// Хранит ссылку на объект класса Graphics на Bitmap, содержащий фон спрайта.


/// </summary>


Graphics bmpCanvas;


/// <summary>


/// Хранит ссылку на список типа SpriteList, которому принадлежит спрайт.


/// </summary>


SpriteList sprites;


/// <summary>


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


/// </summary>


public

SpriteList Sprites


{


internal

set

{ sprites = value

; }


get

{ return

sprites; }


}


/// <summary>


/// Хранит текущее состояние видимости спрайта на экране.


/// </summary>


bool

visible;


/// <summary>


/// Устанавливает и возвращает состояние видимости спрайта на экране.


/// </summary>


public

bool

Visible


{


set


{


if

(value

!= visible)


{


BeginPaint();


if

(value

) Paint(); else

Restore();


EndPaint();


visible = value

;


}


}


get

{ return

visible; }


}


/// <summary>


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


/// </summary>


/// <typeparam name="T">


/// Тип устанавливаемого поля.


/// </typeparam>


/// <param name="outValue">


/// Результирующее значение поля.


/// </param>


/// <param name="inValue">


/// Устанавливаемое значение поле.


/// </param>


/// <remarks>


/// Метод Set убирает спрайт с экрана на время изменения его поля типа T.


/// </remarks>


protected

void

Set<T>(ref

T outValue, T inValue)


{


if

(!outValue.Equals(inValue))


{


bool

VisState = visible;


Visible = false

;


outValue = inValue;


Visible = VisState;


}


}


/// <summary>


/// Хранит положение верхнего левого угла спрайта.


/// </summary>


Point location;


/// <summary>


/// Устанавливает и возвращает положение верхнего левого угла спрайта.


/// </summary>


public

Point Location { get

{ return

location; } }


/// <summary>


/// Хранит размер спрайта.


/// </summary>


Size spriteSize;


/// <summary>


/// Возвращает размер спрайта.


/// </summary>


public

Size SpriteSize { get

{ return

spriteSize; } }


/// <summary>


/// Возвращает прямоугольник спрайта


/// </summary>


public

Rectangle SpriteRect { get

{ return

new

Rectangle(location, spriteSize); } }


/// <summary>


/// Хранит обработчик движения спрайта.


/// </summary>


BeforeMoveEventHandler onBeforeMove;


/// <summary>


/// Устанавливает и возвращает обработчик движения спрайта.


/// </summary>


public

BeforeMoveEventHandler OnBeforeMove


{


set

{ onBeforeMove = value

; }


get

{ return

onBeforeMove; }


}


/// <summary>


/// Готовит изображение спрайта.


/// </summary>


void

BeginPaint()


{


SetMask(z);


for

(int

i = sprites.Count - 1; i >= z + 1; i--)


if

(sprites[i].mask && sprites[i].Visible) sprites[i].Restore();


}


/// <summary>


/// Завершает изображение спрайта.


/// </summary>


void

EndPaint()


{


for

(int

i = z + 1; i < sprites.Count; i++)


if

(sprites[i].mask)


{


if

(sprites[i].Visible) sprites[i].Paint();


sprites[i].mask = false

;


}


}


/// <summary>


/// Определяет факт пересечения прямоугольников двух спрайтов.


/// </summary>


/// <param name="First">


/// Индекс (слой) первого спрайта.


/// </param>


/// <param name="Second">


/// Индекс (слой) второго спрайта.


/// </param>


/// <returns>


/// true

, если спрайты пересекаются, и false

в противном случае.


/// </returns>


bool

Intersect(int

First, int

Second)


{


return

sprites[First].SpriteRect.IntersectsWith


(sprites[Second].SpriteRect);


}


/// <summary>


/// Создает конкретное изображение спрайта.


/// </summary>


/// <remarks>


/// Метод PaintPicture является абстрактным в этом классе и должен быть


/// перекрыт наследниками, формирующими изображение с помощью этого метода.


/// </remarks>


protected

abstract

void

PaintPicture();


/// <summary>


/// Убирает спрайт с экрана.


/// </summary>


protected

internal

virtual

void

Restore()


{


sprites.Canvas.DrawImage(image, location);


}


/// <summary>


/// Помещает спрайт на экран.


/// </summary>


protected

internal

virtual

void

Paint()


{


bmpCanvas.CopyFromScreen(sprites.Parent.RectangleToScreen


(SpriteRect).Location, new

Point(), image.Size);


PaintPicture();


}


/// <summary>


/// Смещает положение спрайта на плоскости XY.


/// </summary>


/// <param name="drift">


/// Вектор смещения.


/// </param>


/// <returns>


/// true

, если смещение произошло, и false

, если нет.


/// </returns>


public

virtual

bool

Move(Size drift)


{


Point newPos = location + drift;


bool

result = true

;


if

(onBeforeMove != null

)


result = onBeforeMove(this

, ref

newPos);


if

(result = result &&


sprites.ClientRect.Contains(new

Rectangle(newPos, spriteSize)))


Set<Point>(ref

location, newPos);


return

result;


}


/// <summary>


/// Перемещает сайт в новое положение на плоскости XY.


/// </summary>


/// <param name="newLocation">


/// Новое положение левого верхнего угла спрайта.


/// </param>


/// <returns>


/// true

, если перемещение произошло, false

, если нет.


/// </returns>


public

virtual

bool

MoveTo(Point newLocation)


{


return

Move((Size)newLocation - (Size)location);


}


}


/// <summary>


/// Собирает и хранит информацию о следах спрайтов, формирующих список.


/// </summary>


/// <remarks>


/// Объекты класса TracedSpriteList в добавление к свойствам своего предка


/// SpriteList создают и поддерживают битовый массив, хранящий информацию о


/// каждом пикселе клиентской области. Если пиксел является следом спрайта,


/// то соответствующий элемент массива имеет значение true

, если нет, то false

.


/// Класс TracedSpriteList перекрывает методы RemoveSpriteAt и Clear, уничтожая


/// информацию о следе удаляемого спрайта.


/// </remarks>


public

class

TracedSpriteList : SpriteList


{


/// <summary>


/// Хранит двумерный битовый массив, отображающий состояние пикселей


/// прямоугольника объекта Control - принадлежит ли пиксел следу спрайта, или фону.


/// </summary>


BitArray[] traceMap;


/// <summary>


/// Возвращает ссылку на битовый массив состояния следов спрайтов.


/// </summary>


internal

BitArray[] TraceMap { get

{ return

traceMap; } }


/// <summary>


/// Инициализирует экземпляр объекта класса TracedSpriteList.


/// </summary>


/// <param name="control">


/// Объект, на котором изображаются спрайты.


/// </param>


public

TracedSpriteList(Control control) : base

(control)


{


traceMap = new

BitArray[ClientRect.Width];


for

(int

i = 0; i < traceMap.Length; i++)


traceMap[i] = new

BitArray(ClientRect.Height);


}


/// <summary>


/// Убирает спрайт из списка.


/// </summary>


/// <param name="z">


/// Индекс-слой устраняемого спрайта.


/// </param>


public

override

void

RemoveSpriteAt(int

z)


{


if

(z > -1 && z < Count)


{


((TracedSprite)this

[z]).TracePoints.Clear();


base

.RemoveSpriteAt(z);


}


}


/// <summary>


/// Очищает список от спрайтов.


/// </summary>


public

override

void

Clear()


{


for

(int

i = 0; i < traceMap.Length; i++)


for

(int

j = 0; j < traceMap[i].Count; j++)


traceMap[i][j] = false

;


base

.Clear();


}


}


/// <summary>


/// Спрайт, оставляющий след.


/// </summary>


/// <remarks>


/// Класс TracedSprite как и его предок является абстрактным.


/// Наследники класса TracedSprite получают возможность оставлять


/// след на клиентской области в форме отдельного пикселя на месте


/// положения своего центра в момент, предшествующий смене положения.


/// Порождать объекты класса TracedSprite должен метод Add, вызванный классом


/// TracedSpriteList. В противном случае будет сгенерирована


/// исключительная ситуация типа ArgumentException.


/// </remarks>


public

abstract

class

TracedSprite : Sprite


{


/// <summary>


/// Хранит true

, если спрайт оставляет след, и false

, если нет.


/// </summary>


bool

traced;


/// <summary>


/// Устанавливает и возвращает значение поля traced.


/// </summary>


public

bool

Traced { set

{ traced = value

; } get

{ return

traced; } }


/// <summary>


/// Хранит true

, если пиксели следа


/// имеют специальный цвет, и false

, если нет.


/// </summary>


/// <remarks>


/// Если пиксели следа не имеют специального цвета, то их цвет определяется


/// как дополнительный до белого от цвета пикселя фона.


/// </remarks>


bool

traceColored;


/// <summary>


/// Устанавливает и возвращает значение поля traceColored.


/// </summary>


public

bool

TraceColored


{


set

{ traceColored = value

; }


get

{ return

traceColored; }


}


/// <summary>


/// Хранит цвет следа.


/// </summary>


Color traceColor = Color.White;


/// <summary>


/// Устанавливает и возвращает цвет следа.


/// </summary>


public

Color TraceColor


{


set

{ traceColored = true

; traceColor = value

; }


get

{ return

traceColor; }


}


/// <summary>


/// Хранит координаты точек следа.


/// </summary>


ArrayList tracePoints = new

ArrayList();


/// <summary>


/// Возвращает ссылку на список координат точек следа.


/// </summary>


public

ArrayList TracePoints { get

{ return

tracePoints; } }


/// <summary>


/// Хранит относительное положение центра спрайта.


/// </summary>


Size centerOffset;


/// <summary>


/// Хранит абсолютное положение центра спрайта.


/// </summary>


Point center;


/// <summary>


/// Возвращает положение центра спрайта.


/// </summary>


public

Point Center { get

{ return

center; } }


/// <summary>


/// Инициализирует экземпляр объекта класса TracedSprite.


/// </summary>


/// <param name="SpriteRect">


/// Прямоугольник спрайта.


/// <param name="sprites">


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


/// </param>


internal

TracedSprite(Rectangle SpriteRect, SpriteList sprites) : base

(SpriteRect, sprites)


{


if

(!(Sprites is

TracedSpriteList))


throw

(new

ArgumentException("Спрайт со следом может быть" +


" только членом списка - наследника TracedSpriteList!"));


centerOffset = new

Size(SpriteSize.Width / 2, SpriteSize.Height / 2);


center = Location + centerOffset;


}


/// <summary>


/// Перемещает спрайт на плоскости XY.


/// </summary>


/// <param name="drift">


/// Вектор смещения.


/// </param>


/// <returns>


/// true

, если перемещение произошло, и false

, если нет.


/// </returns>


public

override

bool

Move(Size drift)


{


if

(Visible && Traced) PutTrace();


bool

result = base

.Move(drift);


if

(result) center = Location + centerOffset;


return

result;


}


/// <summary>


/// Изображает след спрайта.


/// </summary>


/// <remarks>


/// След спрайта изображается в виде пикселя измененного цвета в точке,


/// где находился центр спрайта на момент его перемещения.


/// </remarks>


public

void

PutTrace()


{


for

(int

i = Sprites.Count - 1; i >= 0; i--)


if

(Sprites[i].Visible &&


Sprites[i].SpriteRect.Contains(center))


Sprites[i].Restore();


if

(!((TracedSpriteList)Sprites).TraceMap[center.X - Sprites.ClientRect.Left]


[center.Y - Sprites.ClientRect.Top])


{


if

(!traceColored)


using

(Bitmap bitmap = new

Bitmap(1, 1))


using

(Graphics graphics = Graphics.FromImage(bitmap))


{


graphics.CopyFromScreen(Sprites.Parent.RectangleToScreen(


new

Rectangle(center.X, center.Y, 1, 1)).Location,


new

Point(), bitmap.Size);


Color clr = bitmap.GetPixel(0, 0);


using

(Brush brush = new

SolidBrush(


Color.FromArgb(0xff ^ clr.R, 0xff ^ clr.G, 0xff ^ clr.B)))


Sprites.Canvas.FillRectangle(brush, center.X, center.Y, 1, 1);


}


else


using

(Brush brush = new

SolidBrush(traceColor))


Sprites.Canvas.FillRectangle(brush, center.X, center.Y, 1, 1);


((TracedSpriteList)Sprites).TraceMap[center.X - Sprites.ClientRect.Left]


[center.Y - Sprites.ClientRect.Top] = true

;


tracePoints.Add(new

Point(center.X, center.Y));


}


foreach

(TracedSprite sprite in

Sprites)


if

(sprite.Visible && sprite.SpriteRect.Contains(center))


sprite.Paint();


}


/// <summary>


/// Очищает коллекцию точек следа спрайта.


/// </summary>


~TracedSprite()


{


if

(TracePoints != null

&& TracePoints.Count > 0) TracePoints.Clear();


}


}


/// <summary>


/// Спрайт в форме заполненного эллипса, заданного цвета и градиента.


/// </summary>


public

class

FillEllipseSprite : TracedSprite


{


/// <summary>


/// Хранит цвет спрайта.


/// </summary>


Color color = System.Drawing.Color.Gray;


/// <summary>


/// Возвращает и устанавливает цвет спрайта.


/// </summary>


public

Color Color


{


set

{ Set<Color>(ref

color, value

); }


get

{ return

color; }


}


/// <summary>


/// Хранит указание на то, является ли заполнение эллипса градиентным.


/// </summary>


bool

isGradient = true

;


/// <summary>


/// Устанавливает и возвращает поле isGradient.


/// </summary>


public

bool

IsGradient


{


set

{ Set<bool

>(ref

isGradient, value

); }


get

{ return

isGradient; }


}


/// <summary>


/// Хранит цвета границы градиентного заполнения.


/// </summary>


Color[] colors = { Color.FromArgb(0, 0, 0) };


/// <summary>


/// Устанавливает и возвращает цвета границы градиентного заполнения.


/// </summary>


public

Color[] Colors


{


set

{ Set<Color[]>(ref

colors, value

); }


get

{ return

colors; }


}


/// <summary>


/// Инициализирует экземпляр объекта класса FillEllipseSprite.


/// </summary>


/// <param name="SpriteRect">


/// Прямоугольник эллипса.


/// <param name="sprites">


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


/// </param>


public

FillEllipseSprite(Rectangle SpriteRect, SpriteList sprites)


: base

(SpriteRect, sprites) { }


/// <summary>


/// Изображает спрайт в форме заполненного эллипса.


/// </summary>


protected

override

void

PaintPicture()


{


if

(!isGradient)


using

(Brush brush = new

SolidBrush(color))


Sprites.Canvas.FillEllipse(brush, SpriteRect);


else


using

(GraphicsPath path = new

GraphicsPath())


{


path.AddEllipse(SpriteRect);


using

(PathGradientBrush pthGrBrush = new

PathGradientBrush(path))


{


pthGrBrush.CenterColor = color;


pthGrBrush.SurroundColors = colors;


Sprites.Canvas.FillEllipse(pthGrBrush, SpriteRect);


}


}


}


}


}


Предлагается в среде MS Visual Studio 2005 составить проект, тестирующий описанные классы спрайтов.

Сохранить в соц. сетях:
Обсуждение:
comments powered by Disqus

Название реферата: Методические указания к курсу программирования для студентов физического факультета Сравнительное объектно-ориентированное проектирование

Слов:12806
Символов:128631
Размер:251.23 Кб.