Ирина Эланс

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

Программирование. 7

Содержание

1.Программа шифрования текста методом наложения кода ключа…..стр.3

2.Графическое приложение: игра PacMan……………………………..стр.13

3.Клиент базы данных Microsoft Access……………………………….стр.26

1. Программа шифрования текста наложением кода ключа.

Данная программа предназначена для шифрования файлов наложением кода ключа по методу XOR(исключающего или).

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

2.Поле ввода ключа для шифрования

3.Кнопка для шифрования

4.Кнопка для расшифровки

Результат работы программы:

Исходный текст:

Текст после шифрования ключем “key” :

Файл после расшифровки:

Основной алгоритм (шифрование и дешифрование текста)

Шифрование:

void __fastcall TForm1::Button3Click(TObject *Sender)

{

ifstream inp("Input.txt");

ofstream out("Output.txt");

Edit3->Enabled=false;;

if(!inp)

{

ShowMessage("Отсутствует входной файл!!!");

}

if (!Edit3->Text.Length())

{ ShowMessage("Введите ключ для шифрования!!!");

Edit3->Enabled=true;

}

else

kluch=Edit3->Text.c_str();

int n=strlen(kluch); //длина ключа

int b,j,i=0;

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

{ //преобразование символов ключа в прописные

b=kluch[k];

if(b<=-33&&b>=-64)b+=32; //A->а,Б->б,...(русский алфавит)

if(b==-81||b==-88||b==-86)b+=16; //Ї->ї,Є->є,Ё->ё

if(b<=90&&b>=65)b+=32; //A->a, B->b,...(английский )

kluch[k]=b;

}

char temp,buffer=NULL;//buffer-считываемый символ,temp- преобразованный символ

while(!inp.eof()) //пока не достигнут конец файла

{

inp.read((char*)&buffer,sizeof(buffer));//считываем очередной символ

if(buffer==NULL)break;// если файл пустой

j=fmod(i,n); // переменная j циклически изменяется от 0 до n-1

temp=buffer^(kluch[j]+1);// применяем операцию "исключающее ИЛИ"

out.put(temp); //записываем кодированный символ

i++; //переходим к следующему символу ключевого слова

buffer=NULL;

}

inp.close();

out.close();

ShowMessage("Файл зашифрован");

}

Расшифровка

void __fastcall TForm1::Button1Click(TObject *Sender)

{

ifstream inp("Output.txt");

ofstream out("Uncrypted.txt");

if(!inp)

{

ShowMessage("Отсутствует входной файл!!!");

}

if (!Edit3->Text.Length())

{ ShowMessage("Введите ключ для дешифрования!!!");

Edit3->Enabled=true;

}

int b,j,i=0;

int n=strlen(kluch);

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

{ //преобразование символов ключа в прописные

b=kluch[k];

if(b<=-33&&b>=-64)b+=32; //A->а,Б->б,...(русский алфавит)

if(b==-81||b==-88||b==-86)b+=16; //Ї->ї,Є->є,Ё->ё

if(b<=90&&b>=65)b+=32; //A->a, B->b,...(английский )

kluch[k]=b;

}

char temp,buffer=NULL;

while(!inp.eof())

{

inp.read((char*)&buffer,sizeof(buffer));

if(buffer==NULL)break;

j=fmod(i,n);

temp=buffer^(kluch[j]+1);

out.write((char*)&temp,sizeof(temp));

i++;

buffer=NULL;

}

inp.close();

out.close();

ShowMessage("Файл расшифрован");

}

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

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

#include <vcl.h>

#pragma hdrstop

#include<stdio.h>

#include "Unit1.h"

#include<iostream.h>

#include<conio.h>

#include<fstream.h>

#include<string.h>

#include<math.h>

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

AnsiString fn1;

AnsiString fn2;

char* kluch; //резервируем адрес для ключевого выражения

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

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

void __fastcall TForm1::Button3Click(TObject *Sender)

{

ifstream inp("Input.txt");

ofstream out("Output.txt");

Edit3->Enabled=false;;

if(!inp)

{

ShowMessage("Отсутствует входной файл!!!");

}

if (!Edit3->Text.Length())

{ ShowMessage("Введите ключ для шифрования!!!");

Edit3->Enabled=true;

}

else

kluch=Edit3->Text.c_str();

int n=strlen(kluch); //длина ключа

int b,j,i=0;

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

{ //преобразование символов ключа в прописные

b=kluch[k];

if(b<=-33&&b>=-64)b+=32; //A->а,Б->б,...(русский алфавит)

if(b==-81||b==-88||b==-86)b+=16; //Ї->ї,Є->є,Ё->ё

if(b<=90&&b>=65)b+=32; //A->a, B->b,...(английский )

kluch[k]=b;

}

char temp,buffer=NULL;//buffer-считываемый символ,temp- преобразованный символ

while(!inp.eof()) //пока не достигнут конец файла

{

inp.read((char*)&buffer,sizeof(buffer));//считываем очередной символ

if(buffer==NULL)break;// если файл пустой

j=fmod(i,n); // переменная j циклически изменяется от 0 до n-1

temp=buffer^(kluch[j]+1);// применяем операцию "исключающее ИЛИ"

out.put(temp); //записываем кодированный символ

i++; //переходим к следующему символу ключевого слова

buffer=NULL;

}

inp.close();

out.close();

ShowMessage("Файл зашифрован");

}

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

void __fastcall TForm1::Button1Click(TObject *Sender)

{

ifstream inp("Output.txt");

ofstream out("Uncrypted.txt");

if(!inp)

{

ShowMessage("Отсутствует входной файл!!!");

}

if (!Edit3->Text.Length())

{ ShowMessage("Введите ключ для дешифрования!!!");

Edit3->Enabled=true;

}

int b,j,i=0;

int n=strlen(kluch);

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

{ //преобразование символов ключа в прописные

b=kluch[k];

if(b<=-33&&b>=-64)b+=32; //A->а,Б->б,...(русский алфавит)

if(b==-81||b==-88||b==-86)b+=16; //Ї->ї,Є->є,Ё->ё

if(b<=90&&b>=65)b+=32; //A->a, B->b,...(английский )

kluch[k]=b;

}

char temp,buffer=NULL;

while(!inp.eof())

{

inp.read((char*)&buffer,sizeof(buffer));

if(buffer==NULL)break;

j=fmod(i,n);

temp=buffer^(kluch[j]+1);

out.write((char*)&temp,sizeof(temp));

i++;

buffer=NULL;

}

inp.close();

out.close();

ShowMessage("Файл расшифрован");

}

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

void __fastcall TForm1::N5Click(TObject *Sender)

{

Edit3->Enabled=true;;

Edit3->Text="";

}

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

void __fastcall TForm1::N6Click(TObject *Sender)

{

MessageBox(Form1->Handle,"Программа шифрования текста наложением кода ключа\nРазработал Бутеев Илья\nГруппа АУ-20Д","О программе",MB_OK);

}

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

2. Графическое приложение

Игра «PacMan»

Интерфейс программы

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

2.Статусная строка

3.Игровое поле

Правила Игры

Правила игры в PacMan достаточно просты и понятны. Существует лабиринт, по которому ходят враги – приведения. Цель игры набрать максимальное количество очков за минимальное время и не быть съеденным приведением.

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

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

#include <vcl.h>

#include <iostream.h>

#include <fstream.h>

#include <stdlib.h>

#include <math.h>

#include <mmsystem.hpp>

#pragma hdrstop

#include "Unit1.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------КОНСТАНТЫ---------------------------------------------

//для работы с картой

const byte Height = 12;

const byte Width = 12;

const int CellSize = 25;

const int constMaxWay = CellSize / 3;

const byte mpNone = 0;

const byte mpSeed = 1;

const byte mpEnergizer = 2;

const byte mpPacmanStart = 4;

const int dx[4] = {1, 0, -1, 0}; // смещения, чтобы определить

const int dy[4] = {0, -1, 0, 1}; // какую стену разбивать в BreakWall

//для звуков

TMediaPlayer *MediaPlayer[10];

const byte sMove = 0;

const byte sEatSeed = 1;

const byte sEatEnergizer = 2;

const byte sShowBonus = 3;

const byte sEatBonus = 4;

const byte sEatGhost = 5;

const byte sDie = 6;

const byte sLoose = 7;

const byte sWin = 8;

const byte sNextLevel = 9;

//---------------------ПЕРЕМЕННЫЕ--------------------------------------------

int N = 0;

int p_Life=3;

int LevelSeed = 0;

int LevelEnergizer = 0;

int Score = 0;

//для графики

Graphics::TBitmap* ImageBuffer; // буфер (все в него перед выводом на форму)

Graphics::TBitmap* ImageSprites; //картинка со спрайтами

Graphics::TBitmap* ImageBack; //фон + лабиринт + неизменяемые элементы

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

struct Location

{

byte left_wall; //флаг наличия у данной локации левой и верхней стен

byte up_wall; //правая и нижняя вычисляются через соседние локации

int attr; //Outside = 0, Inside = 1, Border = 2.

int mark; // хранят N при волновой трассировке

int map; // карта

} Maze[Height+1][Width+1];

// +1 чтобы у ряда [Height][] была нижняя стена, а у [][Width] правая

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

class TBonus

{

public:

int Kind; // вид бонуса

int Time; // время до появления следующего

int Life; // время "жизни" бонуса

void Show()

{

if (Kind == 0)

{

switch (random(10)) {

case 0: case 1: case 2: case 3: Kind = 4; break; // 40%

case 4: case 7: case 8: Kind = 3; break; // 30%

case 5: case 6: Kind = 2; break; // 20%

case 9: Kind = 1; break; // 10%

}

Time = (5 + random(10)) * 100;

}

else Time--;

if ((Kind >= 0) && (Time == 0))

{

MediaPlayer[sShowBonus]->Play();

Life = 1000;

}

if (Life != 0)

{

Form1->Sprites->Draw(ImageBack->Canvas,Height/2 * CellSize,Width /2 * CellSize,Kind + 61,true);

Life--;

if (Life == 0) Kind = 0;

}

} Bonus;

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

class TPacman

{

public:

int X;

int Y;

int StartX;

int StartY;

int Dir;

int NewDir;

int SpriteNum;

bool Active;

int ActiveTime;

bool DirFlag[3];

void VerifyDir()

{

if (Maze[X/CellSize][Y/CellSize].left_wall == '1') DirFlag[0] = false;

else DirFlag[0] = true;

if (Maze[X/CellSize][Y/CellSize].up_wall == '1') DirFlag[1] = false;

else DirFlag[1] = true;

if (Maze[X/CellSize + 1][Y/CellSize].left_wall == '1') DirFlag[2] = false;

else DirFlag[2] = true;

if (Maze[X/CellSize][Y/CellSize + 1].up_wall == '1') DirFlag[3] = false;

else DirFlag[3] = true;

}

void Go()

{

Form1->Sprites->Draw(ImageBuffer->Canvas, X, Y, Dir * 3 + SpriteNum);

if ((X % CellSize == 0) && (Y % CellSize == 0))

{

Dir = NewDir;

if (Maze[X/CellSize][Y/CellSize].mark != 1) WaveTracingSolve(X/CellSize,Y/CellSize);

switch (Maze[X/CellSize][Y/CellSize].map) {

case mpSeed : MediaPlayer[sEatSeed]->Play();

Score++;

Maze[X/CellSize][Y/CellSize].map = mpNone;

break;

case mpEnergizer : MediaPlayer[sEatEnergizer]->Play();

Score += 5;

Active = true;

ActiveTime = 10;

Maze[X/CellSize][Y/CellSize].map = mpNone;

break;

case mpPacmanStart : if (Bonus.Life != 0)

{

MediaPlayer[sEatBonus]->Play();

Active = true;

ActiveTime = 10;

Bonus.Kind = 0;

Bonus.Life = 0;

p_Life++;

}

break;

}

LevelRenewSeed();

VerifyDir();

}

if (DirFlag[Dir] == true)

switch (Dir) {

case 0: X--; break;

case 1: Y--; break;

case 2: X++; break;

case 3: Y++; break;

}

} Pacman;

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

class TGhost

{

public:

int X;

int Y;

int StartX;

int StartY;

int Dir;

int SpriteNum;

bool Shy;

int ShyTime;

int CurrN;

bool DirFlag[3];

void NextStep()

{

if ((Maze[X/CellSize - 1][Y/CellSize].mark == CurrN - 1) && (Maze[X/CellSize][Y/CellSize].left_wall == '0')) Dir = 0;

if ((Maze[X/CellSize][Y/CellSize-1].mark == CurrN - 1) && (Maze[X/CellSize][Y/CellSize].up_wall == '0')) Dir = 1;

if ((Maze[X/CellSize+1][Y/CellSize].mark == CurrN - 1) && (Maze[X/CellSize+1][Y/CellSize].left_wall == '0')) Dir = 2;

if ((Maze[X/CellSize][Y/CellSize+1].mark == CurrN - 1) && (Maze[X/CellSize][Y/CellSize+1].up_wall == '0')) Dir = 3;

}

void VerifyDir()

{

if (Maze[X/CellSize][Y/CellSize].left_wall == '1') DirFlag[0] = false;

else DirFlag[0] = true;

if (Maze[X/CellSize][Y/CellSize].up_wall == '1') DirFlag[1] = false;

else DirFlag[1] = true;

if (Maze[X/CellSize + 1][Y/CellSize].left_wall == '1') DirFlag[2] = false;

else DirFlag[2] = true;

if (Maze[X/CellSize][Y/CellSize + 1].up_wall == '1') DirFlag[3] = false;

else DirFlag[3] = true;

}

void Go(int a)

{

if ((X % CellSize == 0) && (Y % CellSize == 0))

{

VerifyDir();

if (random(a*2) == 0) {CurrN = Maze[X/CellSize][Y/CellSize].mark; NextStep();}

else CurrN++;

}

if ((Shy == false) && (DirFlag[Dir] == true))

switch (Dir) {

case 0: X--; break;

case 1: Y--; break;

case 2: X++; break;

case 3: Y++; break;

}

} Ghost[3];

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------ФУНКЦИИ-ФОРМЫ-----------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)

{

Form1->ClientWidth = ::Width * CellSize + 1;

Form1->ClientHeight = ::Height * CellSize + Form1->Label1->Height + 1;

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

{

MediaPlayer[i] = new TMediaPlayer(this);

MediaPlayer[i]->Parent = this;

MediaPlayer[i]->Visible = false;

MediaPlayer[i]->FileName ="sound" + IntToStr(i) + ".wav";

MediaPlayer[i]->Open();

}

ImageBack = new Graphics::TBitmap();

ImageBack->Width = ::Width * CellSize + 1;

ImageBack->Height = ::Height * CellSize + 1;

ImageBuffer = new Graphics::TBitmap();

ImageBuffer->Width = ImageBack->Width;

ImageBuffer->Height = ImageBack->Height;

Randomize;

Form1->DoubleBuffered = true;

TimersRun(false);

}

//---------------------МЕНЮ-ФОРМЫ--------------------------------------------

void __fastcall TForm1::MenuNewClick(TObject *Sender)

{

LevelCreate();

}

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

void __fastcall TForm1::MenuExitClick(TObject *Sender)

{

Form1->Close();

}

//---------------------ОБРАБОТКА-КЛАВИШ----------------------------------

void __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key,

TShiftState Shift)

{

if ((Key >= 37) && (Key <= 40)) Pacman.NewDir = Key - 37;

}

//---------------------ТАЙМЕРЫ-----------------------------------------------

void __fastcall TForm1::TimerMoveTimer(TObject *Sender)

{

ImageBuffer->Canvas->Draw(0,0,ImageBack); // выводим все в буфер

Bonus.Show();

Pacman.Go();

for (int a = 0; a < 4; a++)

{

Ghost[a].Go(a);

if (Ghost[a].Shy == false)

Form1->Sprites->Draw(ImageBuffer->Canvas, Ghost[a].X, Ghost[a].Y, 12 * (a + 1) + Ghost[a].Dir * 3 + Ghost[a].SpriteNum);

else

Form1->Sprites->Draw(ImageBuffer->Canvas, Ghost[a].X, Ghost[a].Y, 12 * (random(3) + 1) + Ghost[a].Dir * 3 + Ghost[a].SpriteNum);

if (((abs(Pacman.Y - Ghost[a].Y) < 10) && (abs(Pacman.X - Ghost[a].X) < 10))

&& (((Pacman.X % CellSize == 0) && (Ghost[a].X % CellSize == 0))

|| ((Pacman.Y % CellSize == 0) && (Ghost[a].Y % CellSize == 0))))

{

if (Pacman.Active == true)

{

MediaPlayer[sEatGhost]->Play();

Ghost[a].Shy = true;

Ghost[a].ShyTime = 15;

}

else

{

MediaPlayer[sDie]->Play();

Form1->TimersRun(false);

p_Life--;

MessageDlg(" ТЕБЯ СЪЕЛИ !!! ", mtInformation, TMsgDlgButtons() << mbOK, 0);

CheckStartPlace();

Form1->TimersRun(true);

}

Label1->Caption = "Всего очков = " + IntToStr(LevelSeed + LevelEnergizer * 5) + ", Очков = " + IntToStr(Score) + ", Бонус = " + IntToStr(Pacman.ActiveTime)+ ", Жизней = " + IntToStr(p_Life);

// если съедены все зерна в уровне, то он пройден - грузим следующий

if (Score == LevelSeed + LevelEnergizer * 5)

{

MediaPlayer[sWin]->Play();

TimersRun(false);

MessageDlg(" Вы победили !!! ", mtInformation, TMsgDlgButtons() << mbOK, 0);

LevelCreate();

}

// если кончились жизни

if (p_Life==0)

{

MediaPlayer[sWin]->Play();

TimersRun(false);

MessageDlg(" Вы проиграли !!! ", mtInformation, TMsgDlgButtons() << mbOK, 0);

LevelCreate();

}

Form1->Canvas->Draw(0,0,ImageBuffer); // выводим все на экран

}

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

void __fastcall TForm1::TimerActiveTimer(TObject *Sender)

{

if (Pacman.ActiveTime > 0)

Pacman.ActiveTime--;

if (Pacman.ActiveTime == 0)

Pacman.Active = false;

for (int a = 0; a < 4; a++)

{

if (Ghost[a].ShyTime > 0)

Ghost[a].ShyTime--;

if (Ghost[a].ShyTime == 0)

Ghost[a].Shy = false;

}

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

void __fastcall TForm1::TimerSpriteTimer(TObject *Sender)

{

if (Pacman.SpriteNum < 2) Pacman.SpriteNum++;

else

{

Pacman.SpriteNum = 0;

MediaPlayer[sMove]->Play();

}

for (int a = 0; a < 4; a++)

if (Ghost[a].SpriteNum < 2) Ghost[a].SpriteNum++;

else Ghost[a].SpriteNum = 0;

}

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

void TForm1::TimersRun(bool active)

{

TimerMove->Enabled = active;

TimerSprite->Enabled = active;

TimerActive->Enabled = active;

}

//---------------------ОБЩИЕ-ФУНКЦИИ-----------------------------------------

//-------------генерация лабиринта по алгоритму Прима------------------------

void BreakWall(int x, int y, int dx, int dy)

//вспомогательная функция. разбивает стену

{

if (dx == -1) Maze[x][y].left_wall = '0';

if (dx == 1) Maze[x + 1][y].left_wall = '0';

if (dy == -1) Maze[x][y].up_wall = '0';

if (dy == 1) Maze[x][y + 1].up_wall = '0';

}

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

void PrimGenerateMaze()

{

Form1->Label1->Caption="Идет генерация лабиринта по алгоритму Прима";

const int Inside = 1;

const int Border = 2;

const int Outside = 0;

int x, y;

int xc, yc;

int xloc, yloc;

bool IsEnd;

int counter;

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

for (x = 0; x < Width; x++)

for (y = 0; y < Height; y++)

{

Maze[x][y].attr = Outside;

Maze[x][y].left_wall = '1';

Maze[x][y].up_wall = '1';

}

//нижняя и правая границы

for (byte i = 0; i < Height; i++)

{

Maze[i][Height].up_wall = '1';

Maze[Height][i].left_wall = '1';

}

//выбираем локацию, с которой начнется генерация

x = random(Width);

y = random(Height);

Maze[x][y].attr = Inside;

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

{

xc = x + dx[i];

yc = y + dy[i];

if ((xc >= 0) && (yc >= 0) && (xc < Width) && (yc < Height))

Maze[xc][yc].attr = Border;

}

{

IsEnd = true;

counter = 0;

//выбираем случайную локацию с атрибутом Border

for (x = 0; x < Width; x++)

for (y = 0; y < Height; y++)

if (Maze[x][y].attr == Border)

counter++;

counter = random(counter) + 1;

for (x = 0; x < Width; x++)

for (y = 0; y < Height; y++)

if (Maze[x][y].attr == Border)

{

counter--;

if (counter == 0)

{

xloc = x;

yloc = y;

goto ExitFor1;

}

ExitFor1:

//присваиваем ей атрибут Inside

Maze[xloc][yloc].attr = Inside;

counter = 0;

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

{

xc = xloc + dx[i];

yc = yloc + dy[i];

if ((xc >= 0) && (yc >= 0) && (xc < Width) && (yc < Height))

{

if (Maze[xc][yc].attr == Inside) counter++;

if (Maze[xc][yc].attr == Outside) Maze[xc][yc].attr = Border;

}

counter = random(counter) + 1;

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

{

xc = xloc + dx[i];

yc = yloc + dy[i];

if ((xc >= 0) && (yc >= 0) && (xc <= Width) && (yc <= Height) && (Maze[xc][yc].attr == Inside))

{

counter--;

if (counter == 0)

BreakWall(xloc, yloc, dx[i], dy[i]);

}

for (x = 0; x < Width; x++)

for (y = 0; y < Height; y++)

if (Maze[x][y].attr == Border)

{

IsEnd = false;

goto ExitFor2;

}

ExitFor2:

ShowMaze();

Sleep(50);

Application->ProcessMessages();

}

while (!IsEnd);

}

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

void ShowMaze()

//рисуем в ImageBack лабиринт и отображаем на канвасе формы

{

ImageBack->Canvas->Brush->Color = clBlack;

ImageBack->Canvas->Pen->Color = clYellow;

ImageBack->Canvas->FillRect(Rect(0,0,Width * CellSize + 1, Height * CellSize + 1));

for (byte i = 0; i <= Height; i++)

for (byte j = 0; j <= Width; j++)

{

if (Maze[i][j].left_wall == '1')

//если у данной локации есть левая стена, то рисуем ее

{

ImageBack->Canvas->MoveTo(i * CellSize, j * CellSize);

ImageBack->Canvas->LineTo(i * CellSize, (j + 1) * CellSize);

}

if (Maze[i][j].up_wall == '1')

//соответственно если есть верхняя стена, то и ее рисуем

{

ImageBack->Canvas->MoveTo(i * CellSize, j * CellSize);

ImageBack->Canvas->LineTo((i+1) * CellSize, j * CellSize);

}

if (Maze[i][j].attr == 2)

//рисуем кружки в Border-локациях при генерации лабирнта

{

ImageBack->Canvas->Brush->Color = clMaroon;

ImageBack->Canvas->Ellipse((i + 0.5) * CellSize - 5, (j + 0.5) * CellSize - 5,(i + 0.5) * CellSize + 5, (j + 0.5) * CellSize + 5);

}

Form1->Canvas->Draw(0,0,ImageBack);

}

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

void CreateMap()

// генерируем карту: заполняем все пространство Seed

// в углах ставим бонусные Energizer

// в центре mpPacmanStart

// + считаем количество Seed и Energizer

{

LevelSeed = 0;

LevelEnergizer = 0;

Score = 0;

Maze[0][0].map = mpEnergizer;

Maze[0][Width-1].map = mpEnergizer;

Maze[Height-1][0].map = mpEnergizer;

Maze[Height-1][Width-1].map = mpEnergizer;

LevelEnergizer = 4;

Maze[Height/2][Width/2].map = mpPacmanStart;

for (byte i = 0; i < Height; i++)

for (byte j = 0; j < Width; j++)

if (Maze[i][j].map == mpNone)

{

Maze[i][j].map = mpSeed;

LevelSeed++;

}

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

void ShowMap()

// рисуем в ImageBack(там уже сгенерирован лабиринт) карту

// инициализируем Pacman.StartX и StartY

// вызываем CheckStartPlace()

{

for (byte i = 0; i < Height; i++)

for (byte j = 0; j < Width; j++)

switch (Maze[i][j].map) {

case mpSeed : Form1->Sprites->Draw(ImageBack->Canvas, i * CellSize, j * CellSize, 60);

break;

case mpEnergizer : Form1->Sprites->Draw(ImageBack->Canvas, i * CellSize, j * CellSize, 61);

break;

case mpPacmanStart : Pacman.StartX = i * CellSize;