Управление движением мячика

program Demo_1;
uses GraphABC;
var 
   x0,y0:integer;
   ball:Picture;//Наш мячик
procedure KeyDown(Key: integer);
   begin
     case Key of
       VK_Left: if x0>0 then x0:=x0-2;// движение лево
       VK_Right: if x0<750 then x0:=x0+2;// движение право
       VK_Down : if y0<550 then y0:=y0+2; // движение низ
       VK_UP : if y0>0 then y0:=y0-2;//движение верх
     end;
      Sleep(10);
      ClearWindow;
   end;
begin
   SetWindowSize(800,600);//Задание размера окна
   ball:=Picture.Create(50,50);//Создание рисунка(мячика)
   ball.Load('ball.bmp');//Загрузка мячика
   //ball.Draw(0,0);//Отображение мячика
   x0:=0;
   y0:=0;
  repeat
      OnKeyDown:=KeyDown;
      ball.Draw(x0,y0);
  until false;
end.

uses GraphABC,Events,CRT;
 
const
  r=10;
  d=3;
  Mydelay = 40;
type
  TDirection = (None, Left, Right, Up, Down);
 
 
var x,y: integer;
  Direction :TDirection;
 
procedure Show;
begin
  SetBrushColor(clBlack);
  Ellipse(x-r,y-r,x+r,y+r);
end;
 
procedure Hide;
begin
  SetBrushColor(clWhite);
  Ellipse(x-r,y-r,x+r,y+r);
end;
 
procedure KeyDown(Key: integer);
begin
  Hide;
  case Key of
   VK_Left: Direction := Left ;
   VK_Up: Direction := Up;
   VK_Right: Direction := Right;
   VK_Down: Direction := Down;
   VK_Escape: Halt;
  end;
  Show
end;
 
procedure KeyPress(Ch: char);
begin
end;
 
begin
  SetWindowCaption('Нажимайте стрелки для перемещения объекта');
  x:=WindowWidth div 2;
  y:=WindowHeight div 2;
 
  Direction := None;
 
  SetPenColor(clWhite);
 
  OnKeyDown:=KeyDown;
  OnKeyPress:=KeyPress;
 
  Show;
  repeat
    if Direction<>None then begin
      Hide;
       HideCursor;
      case Direction of
       Left: begin x:=x-d; if x<=0 then x:=WindowWidth  end;
       Up:  begin y:=y-d; if y<=0 then y:=WindowHeight  end;
       Right: begin x:=x+d; if x>=WindowWidth then x:=0  end;
       Down: begin y:=y+d; if y>=WindowHeight then y:=0  end;
     end;
     Show;
    end;
    Delay(Mydelay);
  until False;
end.

uses GraphABC;
var 
   x0,y0,dx,dy:integer;
   //координаты шарика   
        //координаты направления
procedure KeyDown(Key: integer);
   begin
     case Key of
       VK_Left: if x0>0 then 
          begin
          dx:=-2;// движение лево
          dy:=0;//стираем направление по х, а то будет двигаться по лиагонали )
          end;
       VK_Right: if x0<750 then 
          begin
          dx:=2;// движение право
          dy:=0;//стираем направление по х, а то будет двигаться по лиагонали )
          end;
       VK_Down : if y0<550 then 
          begin
          dy:=2; // движение низ
          dx:=0;//стираем направление по у, а то будет двигаться по лиагонали )
          end;
       VK_UP : if y0>0 then 
          begin
          dy:=-2;//движение верх
          dx:=0;//стираем направление по у, а то будет двигаться по лиагонали )
          end;
     end;
   end;
 
begin
   SetWindowSize(800,600);//Задание размера окна
   x0:=200;   //начальные координаты
   y0:=200;
   circle(x0,y0,20);   //начальное изображение
   lockdrawing;         //блокировка рисования в графическом окне
   repeat               //в цикле с постусловием
   clearwindow;         //очистка экрана
   circle(x0,y0,20);    //изображение
   x0:=x0+dx;           //меняется положение в зависимости от направления
   y0:=y0+dy;
   Sleep(10);         
   redraw;              //перерисовка
   OnKeyDown:=KeyDown;  //обработка нажатия
   until false;
end.

uses GraphABC;
var 
   x0,y0:integer;
   //координаты шарика   
procedure KeyDown(Key: integer);
   begin
     case Key of
       VK_Left: if x0>0 then x0:=x0-2;// движение лево
       VK_Right: if x0<750 then x0:=x0+2;// движение право
       VK_Down : if y0<550 then y0:=y0+2; // движение низ
       VK_UP : if y0>0 then y0:=y0-2;//движение верх
     end;
   clearwindow;         //очистка экрана
   circle(x0,y0,20);    //изображение   
   redraw;              //перерисовка  
   end;
 
begin
   SetWindowSize(800,600);//Задание размера окна
   x0:=200;   //начальные координаты
   y0:=200;
   circle(x0,y0,20);   //начальное изображение
   lockdrawing;         //блокировка рисования в графическом окне
   OnKeyDown:=KeyDown;  //обработка нажатия
end.

uses
  GraphABC;
 
const
  DebugOn=true;                                     // Флаг включения отладочной информации
  SprNum      = 10;                                      // Количество спрайтов
  MapWidth    = 16;                                    // Ширина карты
  MapHeight   = 12;                                   // Высота карты
  SprSize     = 64;                                     // Размер спрайта (ширина=высоте)
  WinWidth = MapWidth*SprSize;                      // Ширина игрового окна
  WinHeight = MapHeight*SprSize;                    // Высота игрового окна
  Levels = 2;                                     // Кол-во уровней
  MaxHeroEnergy = 200;                            // Максимальное уровень здоровья колобка
 
Type UgolType = (UpLeft, UpRight, DownLeft, DownRight);
 
 
// Тип для спрайтов живых объектов
type LiveGraph = record 
    CharCode: char;       // Код при чтении из файла
    h, w: integer;        // Высота и ширина картинка
    Speed:real;           // /Единичная скорость (за иговой цикл)
    picRight: array [0..2] of Picture;    // Массив картинок при движении вправо
    picLeft: array [0..2] of Picture;     // Массив картинок при движении влево
    OffsetSizeX, OffsetSizeY: integer;    // Допуск при столкновении
 
  constructor Create(CharCode: char; FramesNum: byte; FileName: string; Speed:real;  IsHero: boolean);
  begin    
    Self.CharCode:=CharCode;
    //Self.FramesNum:=FramesNum;
    Self.PicRight[0] := Picture.Create(FileName); 
    Self.PicLeft[0] := Picture.Create(FileName); 
    Self.PicLeft[0].FlipHorizontal;
    Self.w := Self.PicRight[0].Width;
    Self.h := Self.PicRight[0].Height;
    Self.Speed:=Speed;
    Self.OffsetSizeX:=6;
    Self.OffsetSizeY:=6;
  end;
End;
 
DirectType = (tLeft, tRight, tUp, tDown);
// Тип для живых объектов
type LiveData = record
    SprType: LiveGraph;
    direct: DirectType;  
    CharCode: char;       // Код при чтении из файла
    x, y: real;           // Текущие координаты
    dx, dy: real;           // 
    //CurentFrame: byte;    // Текущий кадр
    Energy: integer;
    Score: integer;
    IsHero: boolean;
 
  // Добавление энергии
  procedure AddEnergy(EnergyPoints: integer);
  begin
    Self.Energy:=Self.Energy+EnergyPoints;
    If Self.Energy>MaxHeroEnergy then
      Self.Energy:=MaxHeroEnergy;
  end;
    
  // Вывод живого объекта на экран
  procedure Draw();
  begin
    if Self.direct=tRight then
      //SprType.picRight[0].Draw(trunc(Self.x), trunc(Self.y), SprSize, SprSize)
      SprType.picRight[0].Draw(trunc(Self.x), trunc(Self.y))
    else
      SprType.picLeft[0].Draw(trunc(Self.x), trunc(Self.y))
      //SprType.picLeft[0].Draw(trunc(Self.x), trunc(Self.y), SprSize, SprSize)
  end;
end;
    
type SprType = record
  //Num: byte;          
  CharCode: char;     // Код при чтении из файла
  FileName: string;   // Имя файла
  FramesNum: byte;     // Кол-во кадров
  NowFrame: byte;
  Pics: array of Picture;
  Pic1: Picture;
  IsWall: boolean;    // Это стена
  IsFood: boolean;    // Это собирать
  IsExit: boolean;    // Это выход
  
  constructor Create(CharCode: char; FramesNum: byte; FileName: string;  IsWall: boolean; IsFood: boolean; IsExit: boolean);
  begin
    //Self.Num:=Num;
    Self.CharCode:=CharCode;
    Self.FramesNum:=FramesNum;
    Self.FileName:=FileName;
    SetLength(Self.Pics,1);
    Self.Pics[0]:=Picture.Create(FileName);
    Self.IsWall:=IsWall;
    Self.IsFood:=IsFood;
    Self.IsExit:=IsExit;
    Self.NowFrame:=0;
  end;
  procedure draw(ScrX: integer; ScrY: integer);
  begin
    try
    //Self.Pics[NowFrame].Draw(ScrX, ScrY, SprSize, SprSize);
    Self.Pics[NowFrame].Draw(ScrX, ScrY);
    except
      var i:=1;     // Для поиска глюка, можно удалить
    //Self.Pics[NowFrame].Draw(ScrX, ScrY);
    end;
  end;
  procedure NextFrame();
  begin
    NowFrame:=NowFrame mod FramesNum;
  end;
end;
 
var
  picFon: Picture;
  SprMetaData: array of SprType;
  LivesGraph: array of LiveGraph;     // Типы живых спрайтов
  Lives: array[1..10] of LiveData;    // Массив живых объектов
  LevelLives: byte;                   // Кол-во живых объектов на карте
  
  // Переменные для обработки клавиатуры
  kEnter, kLeftKey, kRightKey, kUpKey, kDownKey: boolean;
  kSpaceKey: integer;
  
  World: array [0..MapHeight-1] of array[0..MapWidth-1] of char;
  HMG: integer;               // Кол-во еды на карте
  CurentLevel: integer;       // Текущий уровня
  LevelComplette: boolean;    // Признак того,что уровень закончен
  EndOfGame: boolean;         // Признак того,что игра закончена
  
  // Переменные для отладки
  mx, my: integer;
  str0: string;               // Строка для отладки
 
//####################
procedure sprinit();
begin
 
  SetLength(SprMetaData, 14);
  SprMetaData[0]:=new SprType('R',0,'graph\trava1.png',true,false,false);
  SprMetaData[1]:=new SprType('W',1,'graph\brik1.png',true,false,false);
  SprMetaData[2]:=new SprType('Q',1,'graph\brik2.png',true,false,false);
  SprMetaData[3]:=new SprType('L',1,'graph\land1.png',true,false,false);
  SprMetaData[4]:=new SprType('T',1,'graph\tree1.png',true,false,false);
  SprMetaData[5]:=new SprType('K',1,'graph\tree2.png',true,false,false);
  SprMetaData[6]:=new SprType('B',1,'graph\tree3.png',true,false,false);
  SprMetaData[7]:=new SprType('E',1,'graph\tree4.png',true,false,false);
  
  SprMetaData[8]:=new SprType('G',1,'graph\morkov2.png',false,true,false);
  SprMetaData[9]:=new SprType('D',1,'graph\yabloko.png',false,true,false);  
  SprMetaData[10]:=new SprType('A',1,'graph\arbyz.png',false,true,false);  
  SprMetaData[11]:=new SprType('K',1,'graph\klubnika.png',false,true,false);  
  
  SprMetaData[12]:=new SprType('X',1,'graph\exit1.png',false,false,true);  
  SprMetaData[13]:=new SprType('Z',1,'graph\zabor.png',true,false,false);  
  
end;
 
procedure ReadLevel(Num: byte);
var F:text;h,w:byte;
c: char;
 
begin
 
// Считать фон
picFon:= NEW Picture('graph\fon'+ Num.ToString() +'.png');
 
// Считать карту
assign(F,'level' + Num.ToString() +'.txt');
reset(F);
LevelLives:=1;
for h:=0 to (MapHeight-1) do 
  begin
  for w:=0 to (MapWidth-1) do 
    begin
      read(F,c);
// Живые персонажи      
//      if c='1' then
//      begin
//        Hero.x:=w*SprSize;
//        Hero.y:=h*SprSize;
//        c:='.';
//      end;
      if (c='1') or (c='2') or (c='3') or (c='4') or (c='5') then
      begin
        if c='1'  then
        begin
          Lives[1].IsHero:=true;
        end
        else
          LevelLives+=1;
          
        Lives[LevelLives].CharCode:=c;
        begin
          for var z:=1 to 5 do
            if LivesGraph[z].CharCode=c then
            begin
              Lives[LevelLives].SprType:=LivesGraph[z];
              break;
            end;
        end;
        Lives[LevelLives].x:=w*SprSize;
        Lives[LevelLives].y:=h*SprSize;        
        c:='.';
      end;      
      
      World[h][w]:=c;
    end;
    readln(F);
  end;
  
  // Инициалация живых    $$$ Переписать
  Lives[1].Energy:=100;
  
end;
 
// Инициализация графики "живых" объектов
procedure LiveInit();
Begin
  SetLength(LivesGraph, 6);
  LivesGraph[1]:=new LiveGraph('1',1,'graph\kolobok.png',1,true);
  LivesGraph[2]:=new LiveGraph('2',1,'graph\zayac.png',1,false);
  LivesGraph[3]:=new LiveGraph('3',1,'graph\volk.png',0.6,false);
  LivesGraph[4]:=new LiveGraph('4',1,'graph\medved.png',0.3,false);
  LivesGraph[5]:=new LiveGraph('5',1,'graph\lisa.png',1.2,false);  
End;
 
/// Обработчик нажатия клавиши
procedure KeyDown(Key: integer);
begin
  case Key of
    vk_Left:  kLeftKey := True;
    vk_Right: kRightKey := True;
    vk_Up:  kUpKey := True;
    vk_Down: kDownKey := True;    
    vk_Space: if kSpaceKey = 2 then kSpaceKey := 1;
    vk_Enter: kEnter := True;
  end;
end;
 
/// Обработчик отжатия клавиши
procedure KeyUp(Key: integer);
begin
  case Key of
    vk_Left:  kLeftKey := False;
    vk_Right: kRightKey := False;
    vk_Up:  kUpKey := False;
    vk_Down: kDownKey := False;     
    vk_Space: kSpaceKey := 2;
    vk_Enter: kEnter := False;
  end;
end;
 
/// Обработчик нажатия символьной клавиши
procedure KeyPress(Key: char);
begin
  if (Key in ['G', 'П', 'g', 'п']) and EndOfGame then
  begin
    kSpaceKey := 2;
    kLeftKey := False;
    kRightKey := False;
    kUpKey := False;
    kDownKey := False;
    kEnter := False;
  end;
end;
 
function GetSprByChar(Num: char): SprType;
begin
  for var i:=0 to Length(SprMetaData)-1 do
    if SprMetaData[i].CharCode=Num then
    begin
      result:=SprMetaData[i];
      exit;
    end;
end;
 
Function HowManyGoldOnMap(): integer;
var
  CurSpr: SprType;
  GoldCount: integer;
begin
  GoldCount:=0;
  for var _y := 0 to MapHeight-1 do
  begin
    for var _x := 0 to MapWidth-1 do     
    begin      
      var nn := world[_y][_x];
      if nn <> '.' then 
      begin
        CurSpr:=GetSprByChar(nn);
        if CurSpr.IsFood then
          inc(GoldCount);
        //CurSpr.Pic1.Draw(ScrX, ScrY);
      end;
    end;
  end;
  Result:=GoldCount;
end;
 
Procedure DrawMap();
VAR
  ScrX, ScrY: integer;
  nn: char;
  CurSpr: SprType;
  FonSpr: SprType;
BEGIN
  FonSpr:=GetSprByChar('R');    // Получить спрайт фона
 
  ScrY:=0;
  for var _y := 0 to MapHeight-1 do
  begin
    ScrX := 0;
    for var _x := 0 to MapWidth-1 do 
    
    begin
      
      //FonSpr.Draw(ScrX, ScrY);
      
      nn := world[_y][_x];
      if nn <> '.' then 
      begin
        CurSpr:=GetSprByChar(nn);
        CurSpr.Draw(ScrX, ScrY);
        //CurSpr.Pic1.Draw(ScrX, ScrY);
      end;
      ScrX := ScrX+SprSize;
    end;
    ScrY :=ScrY+SprSize;
  end;
 
// Место для Debug information
  if DebugOn then
  begin
    HMG:=HowManyGoldOnMap();
    mx:=trunc(Lives[1].x) div SprSize; my:=trunc(Lives[1].y) div SprSize;
    str0:= 'L:' + CurentLevel.ToString() +
    'x:' + Lives[1].x.ToString() + ' y:'+ Lives[1].y.ToString() + chr(13) +
    ' mapX:' + mx.ToString() + ' mapY:' + my.ToString() +
    ' Energy:' +  Lives[1].Energy.ToString() +
    ' Food:' +  HMG.ToString();
    textout(0,WindowHeight-15,str0);
  end;
END;
 
Function CoordToMap(coord: integer): integer;
begin
  result:=coord div SprSize;
end;
 
Procedure SprAnalyze(
  CurSpr: SprType; 
  HeroMapX, HeroMapY: integer; 
  IsHero: boolean;
  Ugol: UgolType;
  var dx, dy: real);
begin
  if CurSpr.IsWall then
  begin
    if (Ugol=UpLeft) and (dx<0) then dx:=0;
    if (Ugol=UpRight) and (dx>0) then dx:=0;
    if (Ugol=DownLeft) and (dx<0) then dx:=0;
    if (Ugol=DownRight) and (dx>0) then dx:=0;
    
    if (Ugol=UpLeft) and (dy<0) then dy:=0;
    if (Ugol=UpRight) and (dy<0) then dy:=0;
    if (Ugol=DownLeft) and (dy>0) then dy:=0;
    if (Ugol=DownRight) and (dy>0) then dy:=0;
  end;
  if IsHero and CurSpr.IsFood then
  begin
    world[HeroMapY][HeroMapX]:='.';
    Lives[1].Score+=1;
    Lives[1].AddEnergy(30);
 
  end;  
  if IsHero and (CurSpr.IsExit) and (HMG=0) then
  begin
      LevelComplette:=true;
  end;
end;
  
// Реальные координаты в координаты карты
Function RealCoordToMap(coord: real): integer;
begin
  result:=trunc(coord / SprSize);
end;
 
// NEW!!!
// процедура использует OffsetSizeX и OffsetSizeY - "отступ нечуствительности"  
Procedure SprStena(HeroX, HeroY: real; IsHero: boolean; var dx, dy: real);
VAR
  HeroMapX, HeroMapY: integer;
  //st1, st2, st3, st4: boolean;    // указывает на столкновение спрайта с углами
  CurSpr: SprType;
  OffsetX, OffsetY: real;
BEGIN
 
  //Углы спрайтика:
  // 12
  // 34
  
//  OffsetX:=Lives[1].SprType.OffsetSizeX;
//  OffsetY:=Lives[1].SprType.OffsetSizeY;
// $$$Временно!
  OffsetX:=8;
  OffsetY:=8;
  
  // 1 - верхний левый угол
  HeroMapX:=RealCoordToMap(HeroX+OffsetX+dx);
  HeroMapY:=RealCoordToMap(HeroY+OffsetY+dy);
  CurSpr := GetSprByChar(world[HeroMapY][HeroMapX]);  
  SprAnalyze(CurSpr, HeroMapX, HeroMapY, IsHero, UpLeft, dx, dy);
  
  // 2 - верхний правый угол
  HeroMapX:=RealCoordToMap(HeroX+SprSize-1+dx-OffsetX);
  HeroMapY:=RealCoordToMap(HeroY+dy+OffsetY);
  CurSpr := GetSprByChar(world[HeroMapY][HeroMapX]);  
  SprAnalyze(CurSpr, HeroMapX, HeroMapY, IsHero, UpRight, dx, dy);
  
  // 3 - нижний левый угол
  HeroMapX:=RealCoordToMap(HeroX+dx+OffsetX);
  HeroMapY:=RealCoordToMap(HeroY+SprSize-1+dy-OffsetY);
  CurSpr := GetSprByChar(world[HeroMapY][HeroMapX]);  
  SprAnalyze(CurSpr, HeroMapX, HeroMapY, IsHero, DownLeft, dx, dy); 
  
  // 4 - нижний правый угол
  HeroMapX:=RealCoordToMap(HeroX+SprSize-1+dx-OffsetX);
  HeroMapY:=RealCoordToMap(HeroY+SprSize-1+dy-OffsetY);
  CurSpr := GetSprByChar(world[HeroMapY][HeroMapX]);  
  SprAnalyze(CurSpr, HeroMapX, HeroMapY, IsHero, DownRight, dx, dy);  
END;
 
 
Procedure DrawHero();
BEGIN
    // Вывод живых объектов
  //Lives[1].picRight[0].Draw(trunc(Lives[1].x), trunc(Lives[1].y))    
  for var i:=1 to LevelLives do
    Lives[i].Draw();    
END;
 
// Процедура перемещения колобка
procedure Dvijenie();
var 
  dx, dy: real;
begin
    // Перемещение нашего героя
    // Обработка результата нажатия клавиш управления
    dx:=0; dy:=0;
    if kLeftKey then
    begin
      dx := - 2;
    end;
    if kRightKey then
    begin
      dx := 2;
    end;
    if kUpKey then
    begin
      dy := -2;
    end;
    if kDownKey then
    begin
      dy := 2;
    end;
    
    SprStena(trunc(Lives[1].x),trunc(Lives[1].y), true, dx,dy);
    
    if dx<0 then Lives[1].direct:=tLeft;
    if dx>0 then Lives[1].direct:=tRight;
    Lives[1].dx:=dx;
    Lives[1].dy:=dy;
 
    Lives[1].x:=Lives[1].x+dx;
    Lives[1].y:=Lives[1].y+dy;
 
    // Обработка выхода за экран    
    if (Lives[1].y > WinHeight - Lives[1].SprType.h) then
      Lives[1].y := WinHeight - Lives[1].SprType.h;
    if (Lives[1].y <= 0) then
      Lives[1].y := 0;
    if (Lives[1].x > WinWidth - Lives[1].SprType.w)  then
      Lives[1].x := WinWidth - Lives[1].SprType.w;
    if (Lives[1].x <= 0) then
      Lives[1].x := 0;         
END;
 
function Sign(zz: integer): integer;
begin
  if zz>0 then
    result:=1
  else if zz<0 then
    result:=-1
    else result:=0
end;
 
// Процедура перемещения живых объектов - преследователей
Procedure LivesMove();
var 
  HX, HY: real;
  dx, dy: real;
begin
  HX:=Lives[1].x; HY:=Lives[1].y;
  for var i:= 2 to LevelLives do
  begin
    if ABS(HX-Lives[i].x)>ABS(HY-Lives[i].y) then
    begin
      dx:= Sign(HX-Lives[i].x)*Lives[i].SprType.Speed;
      dy:=0;
    end
    else
    begin
      dx:=0;
      dy:= Sign(HY-Lives[i].y)*Lives[i].SprType.Speed;
    end;
 
    // Логика проверка столкновений со стенами
    SprStena(Lives[i].x, Lives[i].y, false, dx,dy);
    Lives[i].dx:=dx;
    Lives[i].dy:=dy;
    
    // в переменных dx и dy находится итоговое смещение для данного игрового цикла
    // теперь нужно изменить координаты обхекты на это смещение
    Lives[i].x+=dx;
    Lives[i].y+=dy;
    
    // Определяем направление спрайта
    if dx<0 then 
      Lives[i].direct:=tLeft;
    if dx>0 then 
      Lives[i].direct:=tRight;
  end;
 
end;
 
//####################
procedure Stolknovenie();
var
  HeroX, HeroY: real; // Координата середины колобка
  MonX, MonY: real;   // Координата середины охотника
  Rad: real;          // Расстояние от колобка до охотника
  Damage: integer;
begin
  HeroX := Lives[1].x+SprSize div 2; 
  HeroY := Lives[1].y+SprSize div 2;
  
  for var i:=2 to LevelLives do
  begin
    MonX:=Lives[i].x+SprSize div 2; 
    MonY:=Lives[i].y+SprSize div 2;
      Rad:= Sqrt(Sqr(HeroX-MonX) + Sqr(HeroY-MonY));
      if (Rad<(SprSize)) then Damage:=1;
    
    Lives[1].Energy:=Lives[1].Energy-Damage;
  end;
end;
 
begin
  // Инициализация обработчика клавиатуры
  OnKeyDown := KeyDown;
  OnKeyPress := KeyPress;
  OnKeyUp := KeyUp;
  
  SetWindowSize(MapWidth*SprSize, MapHeight*SprSize);
  SetWindowCaption('Игра "Колобок"');
  Window.Top:=10;
  Window.Left:=10;
 
  
  LiveInit();
  sprinit();
  
  for CurentLevel:= 1 to Levels do
  begin
    //Lives[1].x := 0; Lives[1].y := 0;
    LevelComplette:=false;
    EndOfGame:=false;
    ReadLevel(CurentLevel);
    // Основной игровой цикл
    while(true ) do
    begin
        
      LockDrawing;
      // Очистка экрана
      //Window.Clear(clGreen);
      picFon.Draw(0,0); //,ScreenWidth, ScreenHeight);
                 
      // Рисуем карту
      DrawMap();
      
      // Вывести персонаж
      DrawHero();
      Dvijenie();
      LivesMove();
      Stolknovenie();
      
      if LevelComplette then
      begin
        textout(200,200,'Уровень пройден!');
        Redraw();
        read();
 
        break;
      end;    
      if Lives[1].Energy<=0 then
      begin
        EndOfGame:=true;
        break;
      end;
      
      // Вывод экрана
      sleep(1);
      Redraw;
    end;  
      if EndOfGame then
        break;
  end;
  If LevelComplette then
  begin
    Font.Size := 50;
    Font.Color:=clDarkMagenta;
    textout(200,200,'ИГРА ПРОЙДЕНА!');
    Redraw;
  end
  else
  begin
    Font.Size := 50;
    Font.Color:=clRed;
    textout(200,200,'Колобка съели!');
    Redraw;
  end;
end.

uses GraphABC;
var 
   x0,y0,dx,dy:integer;
   //координаты шарика   
        //координаты направления
procedure KeyDown(Key: integer);
   begin
   dy:=0; dx:=0;
     case Key of
       VK_Left: if x0>0 then dx:=-2;// движение лево
       VK_Right: if x0<750 then dx:=2;// движение право
       VK_Down : if y0<550 then dy:=2; 
       VK_UP : if y0>0 then dy:=-2;//движение верх
     end;
  end;
  
procedure KeyUp(key: integer); 
begin
dy:=0; dx:=0;
end;
 
begin
   SetWindowSize(800,600);//Задание размера окна
   x0:=200;   //начальные координаты
   y0:=200;
   circle(x0,y0,20);   //начальное изображение
   lockdrawing;         //блокировка рисования в графическом окне
   repeat               //в цикле с постусловием
   clearwindow;         //очистка экрана
   circle(x0,y0,20);    //изображение
   x0:=x0+dx;           //меняется положение в зависимости от направления
   y0:=y0+dy;
   Sleep(10);         
   redraw;              //перерисовка
   OnKeyDown:=KeyDown;  //обработка нажатия
   OnKeyUp:=KeyUp;
   until false;
end.

program Demo_2;
 
uses
   GraphABC;
 
var
   x, y: integer;
   ball: Picture;//Наш мячик
   fon: Picture;//Наш фон//
   kUpKey, kDownKey, kLeftKey, kRightKey: boolean;// Состояние клавиш Влево,Вправо,Вверх,Вниз
/// Событие - обработчик нажатия клавиатуры
procedure KeyDown(Key: integer);
begin
   case Key of
      vk_Left:  kLeftKey := True;
      vk_Right: kRightKey := True;
      vk_Up:    kUpKey := True;
      vk_Down:  kDownKey := True;
   end;
end;
/// Событие - обработчик отжатия клавиатуры
procedure KeyUp(Key: integer);
begin
   case Key of
      vk_Left:  kLeftKey := False;
      vk_Right: kRightKey := False;
      vk_Up:    kUpKey := False;
      vk_Down:  kDownKey := False;
   end;
end;
 
begin
   LockDrawing;
   SetWindowSize(800, 600);//Задание размера окна
   fon := Picture.Create(800, 600);
   fon.Load('fon.bmp');
   ball := Picture.Create(50, 50);//Создание рисунка(мячика)
   ball.Load('ball.bmp');//Загрузка мячика
   ball.Transparent := true;//Задаёт прозрачность рисунка активным
   ball.TransparentColor := clWhite;//Выбор цвета который должен быть прозрачным
   x := 0;
   y := 0;
   OnKeyDown := KeyDown;
   OnKeyUp:=KeyUp;
   while (true) do
   begin   
      Window.Clear;
      fon.Draw(0, 0);
      ball.Draw(x, y);
      if (kRightKey) then x := x + 1;// Если нажали Вправо, то герой перемещается Вправо на 1
      if (kLeftKey) then x := x - 1;// Если нажали Влево, то герой перемещается Влево на 1
      if (kUpKey) then y := y - 1; // Если нажали Вверх, то герой перемещается Вверх(вперед) на 1
      if (kDownKey) then y := y + 1;// Если нажали Вниз, герой перемещается Вниз(назад) на на 1        
      if (y <= 0) then y := 0;//Если герой коснулся верхнего края экрана, то он не движется в этом направлении
      if (y > 600 - 32) then y := 600 - 32;//Если герой коснулся нижнего края экрана, то он не движется в этом направлении
      if (x <= 0) then x := 0;//Если герой коснулся левого края экрана, то он не движется в этом направлении
      if (x > 800 - 32) then x := 800 - 32;//Если герой коснулся правого края экрана, то он не движется в этом направлении
      Redraw;
   end;
end.

uses
    GraphABC, Timers, ABCObjects;//Используем Юнит Timers и ABCObjects
 
 
type
    Direct = (None, Left, Right, Up, Down);//Тип направления
 
var
    t1: Timer;//переменная таймера
    ball: CircleABC;//переменная Мячика P.S. Класс CircleABC запоминает координаты, и нам не нужны отдельные переменные
    Dir: Direct;//Переменная нашего типа
 
procedure Move;//Тик - тут мы будем совершать ход
begin
    case Dir of
        Left: ball.Left := ball.Left - 1;//ball.Left-Координата x мяча
        Right: ball.Left := ball.Left + 1;
        Up: ball.Top := ball.Top - 1;//ball.Top-Координата y мяча
        Down: ball.Top := ball.Top + 1;
    end;
end;
 
procedure KeyDown(k: integer);
begin
    case k of
        VK_Right: Dir := Right;//Меняем направление
        VK_Left: Dir := Left;
        VK_Up: Dir := Up;
        VK_Down: Dir := Down;
    end;
end;
 
procedure KeyUp(k: integer);
begin
    Dir := None;//Нулевое направление, то есть мяч на месте
end;
 
begin
    t1 := new Timer(10, Move);//T1 - Это переменная класса Timers -  Timer(Задержка в мс,процедура которая выполняется);
    ball := new CircleABC(50, 50, 10, clGreen);// Создаём круг
    t1.Start;//Запускаем таймер
    OnKeyDown := KeyDown;//Тут понятно
    OnKeyUp := KeyUp;
end.