LevelEngine.pas

unit LevelEngine;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  D3DUtils, DirectX, UniDib, DibToolsNE, Dib, DXDraws, DXClass, JPEG, Math;


const
  lvPoly=0;
  lvGrass=1;
  lvStart=2;
  lvExit=3;
  lvKiller=4;
  lvFood=5;
  lvPicture=6;
  lvVertex=7;
  lvHighlight=8;
  lvBackground=9;
  lvCrosshair=10;
//
  ltNormal=0;
  ltAcross=1;
  ltOther=2;
//
  ftNone=0;
  ftPicture=1;
  ftObject=2;  

type

  TRPoint=record
    x,y:double;
    Selected:boolean;
  end;
  PPolygon=^TPolygon;
  TPolygon=record
    Grass:dword;
    Layer:dword;
    Orientation:boolean;
    Vertices:array of TRPoint;
    Triangles:array of TRPoint;
  end;
  TEObject=record
    Pos:TRPoint;
    typ:dword;
    TofF:dword;
    AnimNumber:dword;
  end;
  TEPicture=record
    Name:string[10];
    Texture:string[10];
    Mask:string[10];
    Pos:TRPoint;
    Distance:dword;
    Clipping:dword;
  end;
  TAPolygon=array of TPolygon;
  TAObject=array of TEObject;
  TAPicture=array of TEPicture;
  TALEImage=record
    Texture:TDirect3DTexture2;
    Bmp:TBitmap;
  end;
  TBGPicture=record
    Texture:TDirect3DTexture2;
    srect:TRect;
    x1,y1,x2,y2:double;
  end;
  TPic=record
    Name:string;
    tip:dword;
    Distance,Clipping:dword;
    Width,Height:integer;
    Image:TALEImage;
  end;
  TPC=array of TPic;
  TTool=class;

  TBackup=class
    Polygons:TAPolygon;
    Objects:TAObject;
    Pics:TAPicture;
    name:string[51];
    LGR:string[16];
    Ground:string[10];
    Sky:string[10];
  end;
  
  TLevel=class
  private
    fModified: boolean;
    FAnimIndex: integer;
    fCurrentLevel:TFileName;
    fZoom: double;
    fMode:integer;
    IGround,ISky:integer;
    FLGR: ShortString;
    fFillPolygons:boolean;
    LoadingPictures:boolean;
    FTopChecked: boolean;
    procedure SetModified(const Value: boolean);
    procedure SetAnimIndex(const Value: integer);
    procedure SetMode(const Value: integer);
    procedure SetCurLevel(const Value: TFileName);
    procedure SetZoom(const Value: double);
    procedure GetVertices(srect, drect:TRect;w,h :real; var Vertices:array of TD3DVertex);
    function GetTC(x,y,w,h :real;speed:real):TD3DVertex;
    function GetTexture(FileName:TFileName; mult:boolean; var w,h:integer;f:TFileStream;Size:integer;Pos:integer):TALEImage;
    procedure SetLGR(const Value: ShortString);
    procedure SetFillPolygons(const Value: boolean);
    procedure SetTopChecked(const Value: boolean);
    function IsImageHere(const Tex:TALEImage; x, y: integer; FramedType: integer):boolean;
  public
  //Ñâîéñòâà
    property FillPolygons:boolean read fFillPolygons write SetFillPolygons;
    property TopChecked:boolean read FTopChecked write SetTopChecked;
  public
    ShowGrass:boolean;
    ShowPictures:boolean;
    FillTextures:boolean;
    FullTopChecked:boolean;
    FramePictures:boolean;
    FrameObjects:boolean;
    ShowTextures:boolean;
    ZoomTextures:boolean;
    HighLightVertices:boolean;
    HighLightPO:boolean;
    CrossHair:boolean;
    ShowPolygons:boolean;
    ShowObjects:boolean;
    MapMode:boolean;
    NoCheckOrientation:boolean;
    ShowGrid,SnapToGrid:boolean;
    ShowInfo:boolean;
    UseNormalCapture:boolean;
    UseSmartCapture:boolean;
  //end
  //Level
    Polygons:TAPolygon;
    Objects:TAObject;
    Pics:TAPicture;
    Name:string[51];
    Ground:string[10];
    Sky:string[10];
  //end
  //Palette
    Palette:array[0..10] of Cardinal;
    MapCLoaded:boolean;
    MapColors:array[0..8] of Cardinal;
  //end;
    RNear:integer;
    GridSize:double;
    Width,Height:Integer;
    Center:TRPoint;
    DXDraw:TDXDraw;
    PC:TPC;
    Tool:TTool;
  //Images
    QExit,QKiller,QMoto:TALEImage;
    QFood:array[1..9] of TALEImage;
    BGPicture:TBGPicture;
  //end
//    DelOld:boolean;
  //Backups
    Backups:array of TBackup;
    CurCopy:integer;
  //end
    constructor Create(DD:TDXDraw;w,h:integer);
    destructor Destroy;override;
    procedure New;
    procedure Open(Filename: TFileName);
    procedure Save(Filename: TFileName; Locked: boolean; OnlySelected: boolean);
    procedure Draw;
    procedure SetSize(w,h:integer);
    procedure ZoomFill;
    procedure IncZoom;
    procedure DecZoom;
    procedure MoveCenter(dx,dy:integer);
    function CheckTopology(var p:TRPoint;Full: boolean):boolean;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);
    procedure KeyPressed(key:word);
    procedure WhatHere(p:TRPoint;var npol,n,tp:integer);
    function  StatusLine(p:TPoint):string;
    procedure SortPictures;
    function PromtOnSave:integer;
    procedure SwapBackup(index:integer);
    procedure Undo;
    procedure Redo;
    procedure InitUndoRedoVisible;
//    procedure UnPackLgr(NLgr: string);
    procedure InitTransText;
    procedure ClearBestTimes;
    procedure AddObject(obj:TEObject);
    procedure AddPicture(pic:TEPicture);
    procedure AddPolygon(pol:TPolygon);
    function  DeleteObject(index: integer):boolean;
    procedure DeletePicture(index:integer);
    procedure DeletePolygon(index:integer);
    function  DeleteVertex(npol, n: integer):boolean;
    procedure AddMessage(mess:string;index:integer);
    procedure ExportBMP(FileName:TFileName);
    function SwapColors(t:Cardinal):Cardinal;
    function GetX(x:double):double;
    function GetY(y:double):double;
    function GetOX(x:double):integer;
    function GetOY(y:double):integer;
    function GetRX(x:integer):double;
    function GetRY(y:integer):double;
    function SearchPic(name:string):integer;
    procedure DrawObject(Ob:TEObject);
    procedure DrawPicture(Pic:TEPicture);
    procedure DrawPolygon(Poly:PPolygon);
    procedure DrawVertices(Ver:TRPoint);
    procedure LoadPictures(pPC:TPC);
    procedure LoadBackGroundPic(FileName:TFileName);
    procedure ClearBackGroundPic;
    procedure GetSize(var w,h:double);
    procedure CheckChangingLGR;
    procedure CalcOrientation(Poly:PPolygon);
    function PtInPol(p:TRPoint;pol:PPolygon):boolean;
    function GetRecInfo(FileName:TFileName;var LevelName:TFileName):double;    function GetLevInfo(FileName:TFileName;out LevelName,LgrName,GroundName,SkyName:string):integer;
    function TimeToStr(time:integer):string;
    function FramesToTime(frames:double):integer;
    procedure Normalize(var V:TRPoint);
    procedure SendToBack(npol:integer);
    procedure BringToFront(npol:integer);
    function Intersect(p1,p2,r1,r2:TRPoint;var t:TRPoint):boolean;
  //Properties
    property Mode:integer read fmode write SetMode;
    property CurrentLevel:TFileName read fCurrentLevel write SetCurLevel;
    property Zoom:double read fZoom write SetZoom;
    property Modified:boolean read fModified write SetModified;
    property AnimIndex:integer read FAnimIndex write SetAnimIndex;
    property LGR:shortstring read FLGR write SetLGR;
  end;

  TTool=class
    constructor Create(Par:TLevel);virtual;
    procedure Draw;virtual;abstract;
    procedure MouseDown(Shift: TShiftState;nx,ny:integer);virtual;abstract;
    procedure MouseMove(Shift: TShiftState;nx,ny:integer);virtual;abstract;
    procedure MouseUp(Shift: TShiftState;nx,ny:integer);virtual;abstract;
    procedure KeyPressed(key:word);virtual;
  protected
    Fstate: integer;
    Parent:TLevel;
    x,y:integer;
    procedure Setstate(const Value: integer);virtual;
    property  State:integer read Fstate write Setstate;
  end;

implementation

uses Unit1, Tools, Unit9;

const
  empty:array[0..171] of dword=(
  $B76A0515,$C459ED89,$738FFF48,$C070BC76,$2FB457DF,$BC079E0D,$8A6F0863,
  $38AD2809,$A0F973E0,$8A000080,$60696F37,$41770917,$34268CAC,$98A702AC,
  $80FEA5C9,$B497C0DF,$CA1DD750,$47FB4144,$3860D8F7,$824CCB84,$919A2431,
  $6B0EC976,$CCFC75CC,$9874A5F8,$68BB028E,$BD4CCB44,$F434C499,$684C7A8B,
  $709A5358,$CC2B4FCD,$80E01AD1,$34738F2E,$46D40EE7,$9A02BD1D,$842733BF,
  $A4115806,$751DE410,$2F78B02A,$EF8606E6,$FCF9D5A4,$74542E91,$B191F85D,
  $F955A2F6,$8E47FB23,$E7F4450F,$8C39545D,$388F2ED1,$68BB8FBF,$C8D338A0,
  $3B914989,$880302BD,$9C7F2CE5,$575F93B5,$4BE4A1A0,$6BFD5C11,$FCC63484,
  $0917B191,$A5963B91,$BD3F9874,$89A67D5E,$52E02784,$A2A5A764,$734F4090,
  $90049834,$A5B8CD1F,$C4884381,$19CCC9D8,$65971E2D,$5835FC46,$2D2AD732,
  $98164AFD,$9D84DA81,$B08C5B19,$BE551585,$94FEA538,$DAE3CB95,$04692256,
  $46078DB1,$34A66C93,$F8D0545D,$E11F9084,$ED67B6C3,$F6609838,$025BC860,
  $A7C21C5F,$CF7EA35D,$7F1BA724,$A742DE7B,$ABAFF6D3,$0364A3CC,$BE15232C,
  $454F40AE,$7E0550F4,$FDCBF7E9,$528FFF8C,$1D5347FB,$ABBC7633,$E0B840BF,
  $0D00EF17,$13663E42,$8EF653F6,$50B4B51C,$B81EBACA,$4D10021B,$EC8489E6,
  $DD03F1E1,$BFB89EEB,$CFFE32A9,$2CC32180,$C04E267F,$E3AD6848,$11BAEC15,
  $74D44E48,$289A2471,$98B4B5AD,$D3561A04,$D094BEE2,$57B0FB12,$56ABBC65,
  $3BE20677,$453EF55B,$AFE51501,$216F0469,$34D531E4,$240F30AC,$3CA706D5,
  $2AB55C91,$846BCE68,$C8603641,$FCB9B413,$B39F63AB,$D8C4193B,$A31DA411,
  $CC89B708,$00009EEB,$C51ECBF3,$287C77E7,$894880A0,$88D41B49,$CE0655C4,
  $8FFFAAA6,$91382DBB,$8BA3BBB1,$ECC4B759,$A0E84A30,$B9E37ADC,$C2ED38A0,
  $2838BED5,$CF6D9816,$4B135573,$A9F2194C,$42EB9D04,$4BD7218D,$DB9B072B,
  $826E5023,$3404D8D5,$ED38BE15,$53B610B5,$3258F579,$D6E92088,$97DEEA98,
  $A36A962A,$2FF80C5D,$566BACC5,$D25179C6,$ED672529,$389CFF59,$CB84A7D3,
  $C56F4804,$36C19722,$95C314AF,$4CE960D8);

{ TLevel }

procedure TLevel.AddMessage(mess: string;index:integer);
begin
  with ALEForm,ComboBoxEx1 do begin
    ItemsEx.AddItem(mess,index,index,-1,0,nil);//.Index:=ItemsEx.Count-1;
    ItemIndex:=ItemsEx.Count-1;
//    ItemsEx.ComboItems[0].Index
  end;
end;

procedure TLevel.AddObject(obj: TEObject);
begin
  SetLength(Objects,Length(Objects)+1);
  Objects[High(Objects)]:=Obj;
end;

procedure TLevel.AddPicture(pic: TEPicture);
begin
  SetLength(Pics,Length(Pics)+1);
  Pics[High(Pics)]:=pic;
end;

procedure TLevel.AddPolygon(pol: TPolygon);
begin
  if Length(Pol.Vertices)<=2 then exit;
  SetLength(Polygons,Length(Polygons)+1);
  SetLength(Polygons[High(Polygons)].Vertices,Length(Pol.Vertices));
  with Polygons[High(Polygons)] do begin
    Vertices:=Copy(Pol.Vertices);
    Grass:=Pol.Grass;
  end;
end;

procedure TLevel.BringToFront(npol: integer);
var
  Pol:TPolygon;
  i:integer;
begin
  if npol=0 then exit;
  Modified:=true;
  Pol:=Polygons[npol];
  for i:=npol downto 1 do Polygons[i]:=Polygons[i-1];
  Polygons[0]:=Pol;
end;

procedure TLevel.CalcOrientation(Poly: PPolygon);
var
  angle,da,dx1,dy1,dx2,dy2:double;
  i:integer;
begin
  asm finit end;
  //angle - ïëîùàäü
  with Poly^ do begin
    dx2:=Vertices[1].x-Vertices[0].x;
    dy2:=Vertices[1].y-Vertices[0].y;
    angle:=0;
    for i:=2 to High(Vertices) do
    //if (Vertices[j].x-Vertices[0].x<>0) or (Vertices[j].y-Vertices[0].y<>0) then
    begin
      dx1:=dx2;dy1:=dy2;
      dx2:=Vertices[i].x-Vertices[0].x;
      dy2:=Vertices[i].y-Vertices[0].y;
      da:=dx1*dy2-dy1*dx2;
      angle:=angle+da;
    end;
    if angle<0 then Orientation:=orReverse
    else Orientation:=orNormal;
  end;
end;

procedure TLevel.CheckChangingLGR;
var
  i,j:integer;
  lgrChanged,nopic:boolean;
begin
  i:=0;
  lgrchanged:=false;
  while (i<=High(Pics)) do with Pics[i] do begin
    nopic:=false;
    if (Pics[i].Name='') then begin
      if SearchPic(Texture)<0 then nopic:=true
      else if SearchPic(Mask)<0 then begin
        AddMessage(Format(MessageString[0],[Texture]),iWarning);
        j:=0;
        while (j<=High(PC)) do begin
          if PC[j].tip=ptMask then break;
        end;
        if PC[j].tip=ptMask then Mask:=PC[j].Name
        else nopic:=true;
      end;
    end else begin
      if SearchPic(Pics[i].Name)<0 then nopic:=true;
    end;
    if nopic then begin
      for j:=i to High(Pics)-1 do
        Pics[j]:=Pics[j+1];
      SetLength(Pics,High(Pics));
    end else inc(i);
    lgrchanged:=lgrchanged or nopic;
  end;
  if lgrchanged then AddMessage(MessageString[1],iWarning);
end;

function TLevel.CheckTopology(var p: TRPoint; Full: boolean): boolean;
var
  i,j,k,l:integer;
  tmp:TPolygon;
  cnt:integer;
  w,h:double;
  Vertex:TRPoint;
  sorted:boolean; 
  vers: integer;

procedure Triangulate(const ver:array of TRPoint;np:integer);
var
  nver:array of TRpoint;
  i,n,l,j,n2:integer;
  a,v1,v2,v:TRpoint;
  p1,p2,r1,r2,p,rOld,k1,k2:double;
  
begin
  if Length(ver)<3 then exit;
  if Length(ver)=3 then begin
    Polygons[np].Triangles[cnt*3]:=ver[0];
    Polygons[np].Triangles[cnt*3+1]:=ver[1];
    Polygons[np].Triangles[cnt*3+2]:=ver[2];
    inc(cnt);
    exit;
  end;
  //Îïðåäåëåíèå âåðøèíû ñ íóæíûì èçãèáîì
  j:=-1;
  l:=Length(ver);
  repeat
    if j=high(ver) then begin
      //ShowMessage('Yo');
      //Ïîëèãîí â îäíó ëèíèþ 
      exit;
    end;
    inc(j);
    a:=ver[j];
    v1.x:=ver[(j+1) mod l].x-a.x;
    v1.y:=ver[(j+1) mod l].y-a.y;
    v2.x:=ver[(j+l-1) mod l].x-a.x;
    v2.y:=ver[(j+l-1) mod l].y-a.y;
    p:=v1.x*v2.y-v1.y*v2.x;
  until ((p>0) xor Polygons[np].Orientation) and (p<>0);
  //Íîðìèðîâàíèå
  r1:=sqrt(sqr(v1.x)+sqr(v1.y));
  if r1=0 then r1:=1e-10;
  if r1<>0 then begin
    v1.x:=v1.x/r1;
    v1.y:=v1.y/r1;
  end;
  r2:=sqrt(sqr(v2.x)+sqr(v2.y));
  if r2=0 then r2:=1e-10;
  if r2<>0 then begin
    v2.x:=v2.x/r2;
    v2.y:=v2.y/r2;
  end;
  //Ïîèñê ñå÷åíèÿ
  n:=-1;
  rOld:=0;
  p:=v1.x*v2.x+v1.y*v2.y;
  if p=1 then p:=p-1e-10;
  if p=-1 then p:=p+1e-10;
  for i:=j+2 to l+j-2 do begin
    v.x:=ver[i mod l].x-a.x;
    v.y:=ver[i mod l].y-a.y;
    p1:=(v1.x*v.x+v1.y*v.y);
    p2:=(v2.x*v.x+v2.y*v.y);
//    if (1-p*p)=0 then ShowMessage('Yo');
    k1:=(p1-p*p2)/(1-p*p)/r1;
    k2:=(p2-p*p1)/(1-p*p)/r2;
    if (k1>=0) and (k2>=0) and (k1+k2<=1) then begin
      if (n<0) or ((n>=0) and (k1+k2<rOld)) then begin
        n:=i mod l;
        rOld:=k1+k2;
      end;
    end;
  end;
  if n<0 then begin
    SetLength(nver,3);
    for i:=0 to 2 do nver[i]:=ver[(i+j-1+l) mod l];
    Triangulate(nver,np);
    SetLength(nver,length(ver)-1);
    //nver[0]:=ver[(j-1+l) mod l];
    for i:=0 to high(nver) do nver[i]:=ver[(i+j+1) mod l];
    Triangulate(nver,np);
  end else begin
    n2:=(n-j+1+l) mod l;
    SetLength(nver,n2);
    for i:=0 to n2-1 do nver[i]:=ver[(i+j) mod l];
    Triangulate(nver,np);
    SetLength(nver,l-n2+2);
    for i:=0 to l-n2+1 do nver[i]:=ver[(i+n) mod l];
    Triangulate(nver,np);
  end;
end;

begin
  asm finit end;
  //Ïðîâåðêà òîïîëîãèè
  for i:=0 to High(Polygons) do
   if Polygons[i].Grass<>1 then
   for j:=0 to High(Polygons) do
   if (Polygons[j].Grass<>1)then begin
     for k:=0 to High(Polygons[i].Vertices) do
      for l:=0 to High(Polygons[j].Vertices) do begin
       if not ((abs(k-l)=1) or (abs(k-l)=High(Polygons[i].Vertices)) or (k=l))
        or (i<>j) then
        if Intersect(Polygons[i].Vertices[k],
            Polygons[i].Vertices[(k+1) mod length(Polygons[i].Vertices)],
            Polygons[j].Vertices[l],
            Polygons[j].Vertices[(l+1) mod length(Polygons[j].Vertices)],
            p)
        then begin
          Result:=false;
          TopChecked:=false;
          exit;
        end;
      end;
   end;                 
  TopChecked:=true;
  //Ïðîâåðêà, ÷òî ñòàðò íàõîäèòñÿ âíóòðè íåáà
  i:=0;
  cnt:=1;
  while (i<High(Objects)) do begin
    if Objects[i].typ=4 then break;
    inc(i);
  end;
  if Length(Objects)>0 then
  if Objects[i].typ=4 then begin
    cnt:=0;
    for k:=0 to High(Polygons) do
    if (Polygons[k].Grass=0) then begin
      if PtInPol(Objects[i].Pos,@Polygons[k])
      then inc(cnt);
    end;
  end;
  if not odd(cnt) then begin
    Result:=false;
    AddMessage(MessageString[61],iWarning);
  end else Result:=true;
  if Length(Polygons)>300 then begin
    AddMessage(Format(MessageString[2],[Length(Polygons),300]),iWarning);
    Result:=false;
  end;
  vers:=0;
  for i:=0 to High(Polygons) do begin
    if Length(Polygons[i].Vertices)>1000 then begin
      AddMessage(Format(MessageString[80],[Length(Polygons[i].Vertices),i,1000]),iWarning);
      Result:=false;
    end;
    vers:=vers+Length(Polygons[i].Vertices);
  end;
  if vers>5130 then begin
    AddMessage(Format(MessageString[81],[vers,5130]),iWarning);
    Result:=false;
  end;
  if Length(Objects)>52 then begin
    AddMessage(Format(MessageString[3],[Length(Objects),52]),iWarning);
    Result:=false;
  end;
  if Length(Pics)>5000 then begin
    AddMessage(Format(MessageString[4],[Length(Pics),5000]),iWarning);
    Result:=false;
  end;
  GetSize(w,h);
  if w>=188 then begin
    AddMessage(Format(MessageString[5],[round(w),188]),iWarning);
    Result:=false;
  end;
  if h>=188 then begin
    AddMessage(Format(MessageString[6],[round(w),188]),iWarning);
    Result:=false;
  end;                  
  //Îïðåäåëåíèå ñëîÿ
  for i:=0 to High(Polygons) do with Polygons[i] do
  if Grass=0 then begin
    Layer:=0;
    for k:=0 to High(Polygons) do
    if (k<>i) and (Polygons[k].Grass=0) then begin
      if PtInPol(Vertices[0],@Polygons[k])
      then Layer:=Layer+1;
    end;
  end;
  //Îïðåäåëåíèå îðèåíòàöèè
  for i:=0 to High(Polygons) do with Polygons[i] do
  if Grass=0 then begin
    CalcOrientation(@Polygons[i]);
    if not NoCheckOrientation then
    if (Orientation=orReverse) xor odd(Layer) then begin
      Orientation:=not Orientation;
      for j:=0 to (High(Vertices)-1) div 2 do begin
        Vertex:=Vertices[j];
        Vertices[j]:=Vertices[High(Vertices)-j];
        Vertices[High(Vertices)-j]:=Vertex;
      end;
    end;
  end;
  if not Full then exit;
  //Ñîðòèðîâêà ïî ñëîþ
  for i:=0 to High(Polygons)-1 do begin
    sorted:=true;
    for j:=0 to High(Polygons)-i-1 do
     if ((Polygons[j].Grass=0) and (Polygons[j+1].Grass=0) and (Polygons[j].Layer>Polygons[j+1].Layer))
       or ((Polygons[j].Grass=1) and (Polygons[j+1].Grass=0))
     then begin
       tmp:=Polygons[j];
       Polygons[j]:=Polygons[j+1];
       Polygons[j+1]:=tmp;
       sorted:=false;
     end;
    if sorted then continue;
  end;
//Òðèàíãóëÿöèÿ
  for i:=0 to High(Polygons) do with Polygons[i] do
  if Grass=0 then begin
    SetLength(Triangles,(Length(Vertices)-2)*3);
    cnt:=0;
    Triangulate(Vertices,i);
  end else SetLength(Triangles,0);
  FullTopChecked:=true;
end;

procedure TLevel.ClearBackGroundPic;
begin
  BGPicture.Texture.Free;
  BGPicture.Texture:=nil;
end;

procedure TLevel.ClearBestTimes;
var
  i:integer;
begin
  for i:=0 to 687 do BestTimes[i]:=0;
end;

constructor TLevel.Create(DD:TDXDraw;w,h:integer);
begin
  Inherited Create;
{  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_MIPMAPLODBIAS,D3DTFP_LINEAR);
  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_MIPFILTER,D3DTFP_LINEAR);}
  LoadingPictures:=false;
  //Canvas:=Can;
  DXDraw:=DD;
  Center.x:=0;
  Center.y:=0;
  Zoom:=3;
  Width:=w;
  Height:=h;
  Palette[lvPoly      ]:=0;
  Palette[lvGrass     ]:=32768;
  Palette[lvStart     ]:=255;
  Palette[lvExit      ]:=16777215;
  Palette[lvKiller    ]:=0;
  Palette[lvFood      ]:=16711680;
  Palette[lvPicture   ]:=128;
  Palette[lvVertex    ]:=255;
  Palette[lvHighlight ]:=16711680;
  Palette[lvBackground]:=12632256;
  Palette[lvCrosshair ]:=255;
  //for i:=0 to High(Palette) do Palette[i]:=SwapColors(Palette[i]);
  {Bitmap:=TBitmap.Create;
  Bitmap.Width:=Width;
  Bitmap.Height:=Height;}
 // Bitmap.PixelFormat:=pf24bit;
  Modified:=false;
  TopChecked:=true;
  Polygons:=nil;
  Objects:=nil;
  Tool:=nil;
  //Obj:=TUniDib.Create(40,40,8,SBU_NONE);
  //Obj.PixelFormat:=pf24bit;
  //Obj.Width:=40;
  //Obj.Height:=40;
  AnimIndex:=0;
  fLgr:='';
  SetLength(Backups,0);
  CurCopy:=-1;
  //New;
  InitUndoRedoVisible;
  ClearBackGroundPic;
  if DXDraw<>nil then QMoto:=GetTexture('QMoto',false,w,h,nil,0,0);
end;

procedure TLevel.DecZoom;
begin
  Zoom:=Zoom/1.5;
  Draw;
end;

function TLevel.DeleteObject(index: integer):boolean;
//true åñëè îáúåêò áûë óäàëåí
var
  i,j:integer;
  tp:integer;

procedure Del;
var
  i:integer;
begin
  for i:=index to High(Objects)-1 do
    Objects[i]:=Objects[i+1];
  SetLength(Objects,High(Objects));
  Result:=true;
end;

begin
  Result:=false;
  if (index<0) or (index>High(Objects)) then exit;
  with Objects[index] do begin
    tp:=typ;
    if tp=4 then begin
      AddMessage(MessageString[7],iWarning);
      exit;
    end;
    if (tp=2) or (tp=3) then Del;
    if tp=1 then begin
      j:=0;
      for i:=0 to High(Objects) do
       if Objects[i].typ=1 then inc(j);
      if j>=2 then Del
      else AddMessage(MessageString[8],iWarning);
    end;
  end;
end;

procedure TLevel.DeletePicture(index: integer);
var
  i:integer;
begin
  if (index<0) or (index>High(Pics)) then exit;
  for i:=index to High(Pics)-1 do
   Pics[i]:=Pics[i+1];
  SetLength(Pics,High(Pics));
end;

procedure TLevel.DeletePolygon(index: integer);
var
  i:integer;
begin
  SetLength(Polygons[index].Vertices,0);
  for i:=index to High(Polygons)-1 do
   Polygons[i]:=Polygons[i+1];
  if index<=High(Polygons) then SetLength(Polygons,High(Polygons));
end;

function TLevel.DeleteVertex(npol, n: integer):boolean;
//true åñëè áûëà ïîïûòêà óäàëèòü ïîëèãîí
var
  i:integer;
begin
  with Polygons[npol] do
  if Length(Vertices)>3 then begin
    for i:=n to High(Vertices)-1 do
     Vertices[i]:=Vertices[i+1];
    if n<=High(Vertices) then SetLength(Vertices,High(Vertices));
    Result:=false;
  end else begin
    if Length(Polygons)>1 then DeletePolygon(npol)
    else AddMessage(MessageString[9],iWarning);
    Result:=true;
  end;
end;

destructor TLevel.Destroy;
var
  i:integer;
begin
  SetLength(Objects,0);
  SetLength(Polygons,0);
  SetLength(Pics,0);
  for i:=0 to High(PC) do begin
    PC[i].Image.Texture.Free;
    PC[i].Image.Bmp.Free;
  end;
  SetLength(PC,0);
  QExit.Texture.Free;
  QExit.Bmp.Free;
  for i:=1 to 9 do begin
   QFood[i].Texture.Free;
   QFood[i].Bmp.Free;
  end;
  QKiller.Texture.Free;
  QKiller.Bmp.Free;
  QMoto.Texture.Free;
  for i:=0 to High(Backups) do Backups[i].Free;
  SetLength(Backups,0);
  ClearBackGroundPic;
  Inherited;
end;

procedure TLevel.Draw;
var
  i,j,w,h,old:integer;
  p,p2:TPoint;
  r:TRect;
  vp: TD3DViewport7;
  mtrl: TD3DMaterial7;
  matProj, matView: TD3DMatrix;
  r2: TD3DRect;
  Vertices:array[0..3] of TD3DVertex;
begin
  if DXDraw=nil then exit;
  if not DXDraw.CanDraw then exit;
  if LoadingPictures then exit;
  asm finit end;
//View matrix
  D3DUtil_SetViewMatrix(matView,MakeD3DVector(0,0,-1),MakeD3DVector(0,0,1),MakeD3DVector(0,0,0));
  DXDraw.D3DDevice7.SetTransform( D3DTRANSFORMSTATE_VIEW, matView);
//Viewport
  FillChar(vp, SizeOf(vp), 0);
  vp.dwX := 0;
  vp.dwY := 0;
  vp.dwWidth := DXDraw.SurfaceWidth;
  vp.dwHeight := DXDraw.SurfaceHeight;
  vp.dvMinZ := 0.0;
  vp.dvMaxZ := 1.0;
  DXDraw.D3DDevice7.SetViewport(vp);
//Material
  FillChar(mtrl, SizeOf(mtrl), 0);
  mtrl.ambient.r := 1.0;
  mtrl.ambient.g := 1.0;
  mtrl.ambient.b := 1.0;
  mtrl.diffuse.r := 1.0;
  mtrl.diffuse.g := 1.0;
  mtrl.diffuse.b := 1.0;
  DXDraw.D3DDevice7.SetMaterial(mtrl);
  DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, $ffffffff);
//Projection
  D3DUtil_SetProjectionMatrix(matProj,2*arctan(DXDraw.SurfaceHeight/2),DXDraw.SurfaceHeight/DXDraw.SurfaceWidth,-1,1);
  DXDraw.D3DDevice7.SetTransform(D3DTRANSFORMSTATE_PROJECTION, matProj );
//  if Polygons=nil then exit;
//  DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_CULLMODE, Ord(D3DCULL_NONE));
  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_MAGFILTER,ord(D3DTFG_ANISOTROPIC));
//  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_MINFILTER,ord(D3DTFN_ANISOTROPIC));
//  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_MIPFILTER,ord(D3DTFP_LINEAR));
  DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0);
  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_COLOROP,D3DTA_TEXTURE);
  DXDraw.D3DDevice7.SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTA_TEXTURE);
  DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_CULLMODE, Ord(D3DCULL_NONE));
  {DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_ZWRITEENABLE,0);
  DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_ZENABLE,0);}
  if Objects=nil then exit;
  with DXDraw,Surface.Canvas,D3DDevice7 do begin
    DXDraw.D3DDevice7.BeginScene;
    IGround:=-1;
    ISky:=-1;
    if FillPolygons and TopChecked and (Mode=mdView) then begin
      if MapMode then IGround:=MForeGround
      else begin
        IGround:=SearchPic(Ground);
        ISky:=SearchPic(Sky);
        if IGround>=0 then
          SetTexture(0,PC[IGround].Image.Texture.Surface.IDDSurface7);
        end;
    end;
    DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 0);
    DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0);
    r2.x1 := 0;
    r2.y1 := 0;
    r2.x2 := DXDraw.SurfaceWidth;
    r2.y2 := DXDraw.SurfaceHeight;
    DXDraw.D3DDevice7.Clear(1, r2, D3DCLEAR_STENCIL or D3DCLEAR_ZBUFFER, 0, 1, 0);
    if (IGround<0) or (MapMode and (IGround>=0)) then begin
      //Clear Screen
      if IGround>=0 then
        DXDraw.D3DDevice7.Clear(1, r2, D3DCLEAR_TARGET, SwapColors(MapColors[IGround]), 1, 0)
      else DXDraw.D3DDevice7.Clear(1, r2, D3DCLEAR_TARGET, Self.Palette[lvBackground], 1, 0);
    end else begin
      w:=PC[IGround].Width;
      h:=PC[IGround].Height;
      Vertices[0]:=GetTC(0, 0,w,h,SlowSpeed);
      Vertices[1]:=GetTC(DXDraw.SurfaceWidth-1, 0,w,h,SlowSpeed);
      Vertices[2]:=GetTC(0, DXDraw.SurfaceHeight-1,w,h,SlowSpeed);
      Vertices[3]:=GetTC(DXDraw.SurfaceWidth-1, DXDraw.SurfaceHeight-1,w,h,SlowSpeed);
      DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, Vertices[0], 4, 0);
    end;
    //Ôîíîâûé ðèñóíîê
    with BGPicture do
    if Texture<>nil then begin
      r.Left:=GetOX(x1);
      r.Right:=GetOX(x2);
      r.Top:=GetOY(y1);
      r.Bottom:=GetOY(y2);
      GetVertices(srect,r,Texture.Surface.Width,Texture.Surface.Height,Vertices);
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 0);
      SetTexture(0,BGPicture.Texture.Surface.IDDSurface7);
      DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, Vertices[0], 4, 0);
    end;
    //end
    //Grid
    if ShowGrid then begin
      Pen.Color:=SwapColors(Self.Palette[lvPoly]);
      Pen.Style:=psDot;
      Pen.Mode:=pmMergeNotPen;
      Brush.Style:=bsClear;
      for i:=Round((Center.x-Width/2/Zoom)/GridSize)-1 to Round((Center.x+Width/2/Zoom)/GridSize)+1 do begin
        MoveTo(GetOX(i*GridSize),0);
        LineTo(GetOX(i*GridSize),Height-1);
      end;
      for i:=Round((Center.y-Height/2/Zoom)/GridSize)-1 to Round((Center.y+Height/2/Zoom)/GridSize)+1 do begin
        MoveTo(0,GetOY(i*GridSize));
        LineTo(Width-1,GetOY(i*GridSize));
      end;
      Pen.Mode:=pmCopy;
      Release;
    end;
    //end
    //Ñîäðàíî èç èíåòà - âêëþ÷àåì çàïèñü â òðàôàðåò
    {if Mode=mdView then begin
      SetRenderState(D3DRENDERSTATE_STENCILENABLE,1);
      SetRenderState(D3DRENDERSTATE_STENCILFUNC,  D3DPCMPCAPS_ALWAYS);
      SetRenderState(D3DRENDERSTATE_STENCILREF,      $1 );
      SetRenderState(D3DRENDERSTATE_STENCILMASK,     $ffffffff );
      SetRenderState(D3DRENDERSTATE_STENCILWRITEMASK,$ffffffff );
      SetRenderState(D3DRENDERSTATE_STENCILZFAIL, D3DSTENCILCAPS_KEEP );
      SetRenderState(D3DRENDERSTATE_STENCILFAIL,  D3DSTENCILCAPS_KEEP );
      SetRenderState(D3DRENDERSTATE_STENCILPASS,  D3DSTENCILCAPS_REPLACE );
    end;}
    //Êîíåö
    if ShowPolygons then
      for i:=0 to High(Polygons) do DrawPolygon(@Polygons[i]);
    //Ñîäðàíî èç èíåòà - ðèñóåì ñ èñïîëüçîâàíèåì òðàôàðåòà
    {if Mode=mdView then begin
      SetRenderState(D3DRENDERSTATE_STENCILENABLE,0);
      SetRenderState(D3DRENDERSTATE_STENCILFUNC,  D3DPCMPCAPS_EQUAL );
      SetRenderState(D3DRENDERSTATE_STENCILPASS,  D3DSTENCILCAPS_KEEP );
      SetRenderState(D3DRENDERSTATE_SRCBLEND,     D3DPBLENDCAPS_DESTCOLOR );
      SetRenderState(D3DRENDERSTATE_DESTBLEND,    D3DPBLENDCAPS_ZERO );
    end;}
    //Êîíåö
    j:=High(Pics)+1;
    //Õèòðûé ïîðÿäîê ðèñîâàíèå - â ýëìå òàêîé :(
    i:=0;
    while i<=High(Pics) do begin
     old:=i;
     if Pics[old].Distance>=500 then begin
       while (Pics[i].Distance=Pics[old].Distance) do begin
         inc(i);
         if (i=High(Pics)+1) then break;
       end;
       for j:=i-1 downto old do DrawPicture(Pics[j]);
       j:=0;
     end else begin
       j:=i;
       break;
     end;
    end;
    {if Mode=mdView then
      SetRenderState(D3DRENDERSTATE_STENCILENABLE,0);
    SetRenderState(D3DRENDERSTATE_STENCILENABLE,0);}
    //DXDraw.Surface.Canvas.Release;
    if ShowObjects then
      for i:=0 to High(Objects) do DrawObject(Objects[i]);
    i:=j;
    while i<=High(Pics) do begin
     old:=i;
     while (Pics[i].Distance=Pics[old].Distance) do begin
       inc(i);
       if (i=High(Pics)+1) then break;
     end;
     for j:=i-1 downto old do DrawPicture(Pics[j]);
    end;
    //DXDraw.Surface.Canvas.Release;
    if (Tool<>nil) and (Mode=mdEdit) then Tool.Draw;
    if CrossHair then begin
      GetCursorPos(p);
      r:=ALEForm.PaintBox1.ClientRect;
      r.TopLeft:=ALEForm.PaintBox1.ClientToScreen(r.TopLeft);
      r.BottomRight:=ALEForm.PaintBox1.ClientToScreen(r.BottomRight);
      if PtInRect(r,p) then begin
        p2:=ALEForm.PaintBox1.ClientToScreen(Point(0,0));
        p.x:=p.x-p2.x;
        p.y:=p.y-p2.y;
        Pen.Color:=Level.SwapColors(Self.Palette[lvCrosshair]);
        Pen.Style:=psDot;
        Brush.Style:=bsClear;
        MoveTo(0,p.y);
        LineTo(Width,p.y);
        MoveTo(p.x,0);
        LineTo(p.x,Height);
      end;
    end;                       
    Release;
    DXDraw.D3DDevice7.EndScene;
  end;
  DXDraw.Flip;
  asm finit end;
  //Canvas.Draw(0,0,Bitmap);
end;

procedure TLevel.DrawObject(Ob: TEObject);
const
  OFaces=12;
var
  r,n,i:integer;
  srect,drect:TRect;
  Tmp:TALEImage;
  Vertices:array[0..OFaces] of TD3DVertex;
  Color:Cardinal;
begin
  with DXDraw.D3DDevice7{,DXDraw.Surface.Canvas},Ob do begin
    Color:=$000000;
    r:=round(Radius*Zoom);
    if not MapMode or (Mode=mdEdit) then begin
      Tmp.Texture:=nil;
      drect:=Bounds(GetOX(Pos.x)-r,GetOY(Pos.y)-r,2*r,2*r);
      srect:=Bounds(0,0,64,64);
    end;
    case typ of
      1: if MapMode and (Mode=mdView) then Color:=SwapColors(MapColors[MExit]) else begin
        //if QExit<>nil then Bounds(-(AnimIndex mod 50)*40,0,40,40);
        Color:=Palette[lvExit];
        Tmp:=QExit;
      end;
      2: if MapMode and (Mode=mdView) then Color:=SwapColors(MapColors[MFood]) else begin
        if (AnimNumber>=1) and (AnimNumber<=9) then
         n:=AnimNumber else n:=1;
        if QFood[n].Texture=nil then n:=1;
        //if QFood[n]<>nil then begin
        //  srect:=Bounds(0,0,64,64);//Bounds(-(AnimIndex mod (QFood[n].Surface.Width div 40))*40,0,40,40);
        //end;
        Color:=Palette[lvFood];
        Tmp:=QFood[n];
      end;
      3: if MapMode and (Mode=mdView) then Color:=SwapColors(MapColors[MKiller]) else begin
        //if QKiller<>nil then srect:=Bounds(0,0,64,64);//srect:=Bounds(-(AnimIndex mod 33)*40,0,40,40);
        Color:=Palette[lvKiller];
        Tmp:=QKiller;
      end;
      4: if MapMode and (Mode=mdView) then Color:=SwapColors(MapColors[MBikeA]) else begin
        if QMoto.Texture<>nil then begin
          srect:=Bounds(0,0,QMoto.Texture.Surface.Width-1,QMoto.Texture.Surface.Height-1);
          drect:=Bounds(GetOX(Pos.x)-round(58/pmoto*Zoom/100),GetOY(Pos.y)-round(273/pmoto*Zoom/100),
           round(359/100*Zoom/pmoto),round(331/100*Zoom/pmoto));
        end;
        Color:=Palette[lvStart];
        Tmp:=QMoto;
      end;
    end;
    if MapMode and (Mode=mdView) then begin
      //Color:=SwapColors(Color);
      if typ<>4 then begin
        Vertices[0]:=GetTC(GetX(Pos.x)-1, GetY(Pos.y)-1,1,1,1);
        Vertices[1]:=GetTC(GetX(Pos.x)+1, GetY(Pos.y)-1,1,1,1);
        Vertices[2]:=GetTC(GetX(Pos.x)+1, GetY(Pos.y)+1,1,1,1);
        Vertices[3]:=GetTC(GetX(Pos.x)-1, GetY(Pos.y)+1,1,1,1);
        Vertices[4]:=Vertices[0];
      end else begin
        Vertices[0]:=GetTC(GetX(Pos.x+121.5/pmoto/100)-1, GetY(Pos.y-107/pmoto/100)-1,1,1,1);
        Vertices[1]:=GetTC(GetX(Pos.x+121.5/pmoto/100)+1, GetY(Pos.y-107/pmoto/100)-1,1,1,1);
        Vertices[2]:=GetTC(GetX(Pos.x+121.5/pmoto/100)+1, GetY(Pos.y-107/pmoto/100)+1,1,1,1);
        Vertices[3]:=GetTC(GetX(Pos.x+121.5/pmoto/100)-1, GetY(Pos.y-107/pmoto/100)+1,1,1,1);
        Vertices[4]:=Vertices[0];
      end;
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Color);
      SetTexture(0,nil);
      DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Vertices[0], 5, 0);
      exit;
    end;
    //Brush.Style:=bsClear;
    DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 1);
//    DXDraw.Surface.Canvas.Release;
    if Tmp.Texture<>nil then begin
      SetTexture(0,Tmp.Texture.Surface.IDDSurface7);
    end;
    if (Tmp.Texture=nil) or FrameObjects then begin
      for i:=0 to OFaces do
        Vertices[i]:=GetTC(GetX(Pos.x)+round(cos(i/OFaces*2*pi)*r), GetY(Pos.y)+round(sin(i/OFaces*2*pi)*r),1,1,1);
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Color);
      SetTexture(0,nil);
      DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Vertices[0], OFaces+1, 0);
//      Ellipse(GetX(Pos.x)-r,GetY(Pos.y)-r,GetX(Pos.x)+r,GetY(Pos.y)+r)
    end else begin
      GetVertices(srect,drect,Tmp.Texture.Surface.Width,Tmp.Texture.Surface.Height,Vertices);
      DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, Vertices[0], 4, 0);
    end;
    if HighLightPO then begin
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Self.Palette[lvHighlight]);
      SetTexture(0,nil);
      DrawVertices(Pos);
    end;
    //DXDraw.Surface.StretchDraw(drect,srect,ALEForm.DXImageList1.Items[0].PatternSurfaces[0],true);
  end;
end;

procedure TLevel.DrawPicture(Pic: TEPicture);
var
  k,j,w,h:integer;
  wk,hk:double;
  Rect:TRect;
  Vertices:array[0..4] of TD3DVertex;
  NoDrawVert:boolean;
begin
  if not (MapMode and (Mode=mdView)) then
  with DXDraw,Surface.Canvas,D3DDevice7,Pic do begin
    asm finit end;
    if Pic.Name='' then begin
      k:=SearchPic(Mask);
      j:=SearchPic(Texture);
    end else begin
      k:=SearchPic(Pic.Name);
      j:=0;
    end;
    if (j<0) or (k<0) then exit;
    wk:=PC[k].Width*pz*Zoom*1.041;
    hk:=PC[k].Height*pz*Zoom*1.041;
    Rect:=Bounds(GetOX(Pos.x),GetOY(Pos.y),
      round(wk),round(hk));

    if (Pic.Name='') then begin
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 0);
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0);
      w:=PC[j].Width;
      h:=PC[j].Height;
      Vertices[0]:=GetTC(GetX(Pic.Pos.x), GetY(Pic.Pos.y),w,h,SlowSpeed);
      Vertices[1]:=GetTC(GetX(Pic.Pos.x)+wk, GetY(Pic.Pos.y),w,h,SlowSpeed);
      Vertices[2]:=GetTC(GetX(Pic.Pos.x), GetY(Pic.Pos.y)+hk,w,h,SlowSpeed);
      Vertices[3]:=GetTC(GetX(Pic.Pos.x)+wk, GetY(Pic.Pos.y)+hk,w,h,SlowSpeed);
      SetTexture(0,PC[j].Image.Texture.Surface.IDDSurface7);
    end else begin
      GetVertices(Bounds(0,0,1,1),rect,2,2,Vertices);
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 1);
      SetTexture(0,PC[k].Image.Texture.Surface.IDDSurface7);
    end;

//    if IntersectRect(outr,Rect,ClipRect) then
    NoDrawVert:=true;
    if Name='' then begin
      if ShowTextures then begin
        if not FillTextures then begin
          SetTexture(0,PC[j].Image.Texture.Surface.IDDSurface7);
//          SetTexture(0,nil);
//          DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Self.Palette[lvPicture]);
          Vertices[4]:=Vertices[2];
          Vertices[2]:=Vertices[3];
          Vertices[3]:=Vertices[4];
          Vertices[4]:=Vertices[0];
          DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Vertices[0], 5, 0);
        end else DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, Vertices[0], 4, 0);
        NoDrawVert:=false;
      end;
    end else begin
      if ShowPictures or FramePictures then NoDrawVert:=false;
      if ShowPictures then DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLESTRIP, D3DFVF_VERTEX, Vertices[0], 4, 0);
      if Framepictures then begin
        SetTexture(0,nil);
        DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Self.Palette[lvPicture]);
        Vertices[4]:=Vertices[2];
        Vertices[2]:=Vertices[3];
        Vertices[3]:=Vertices[4];
        Vertices[4]:=Vertices[0];
        DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Vertices[0], 5, 0);
      end;
    end;
    if not NoDrawVert and HighLightPO then begin
      DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Self.Palette[lvHighlight]);
      SetTexture(0,nil);
      DrawVertices(Pos);
    end;
  end;
end;

procedure TLevel.DrawPolygon(Poly: PPolygon);
var
  Points:array of TD3DVertex;
  j:integer;
  w,h:integer;
  s:real;
  NoDrawVert:boolean;
begin
  with DXDraw.D3DDevice7,Poly^ do
   if not (Grass=1) or ShowGrass then begin
     w:=1;h:=1;
     if MapMode and (Mode=mdView) then begin
       if Grass=0 then begin
         if odd(Layer) then j:=MForeGround
         else j:=MBackGround;
         DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, SwapColors(MapColors[j]));
         SetTexture(0,nil);
       end
     end else begin
       if Grass=1 then begin
         DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Palette[lvGrass]);
         SetTexture(0,nil);
       end else begin
         if odd(Layer) then j:=IGround
         else j:=ISky;
         if j>=0 then begin
           SetTexture(0,PC[j].Image.Texture.Surface.IDDSurface7);
           w:=PC[j].Width;
           h:=PC[j].Height;
         end else begin
           SetTexture(0,nil);
           DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Palette[lvPoly]);
       end;
       end;
     end;
     if Odd(Layer) then s:=SlowSpeed
       else s:=FastSpeed;
     NoDrawVert:=true;
     if (Mode=mdView) and FillPolygons and FullTopChecked and (Grass=0) then begin
       SetLength(Points,Length(Triangles));
       for j:=0 to High(Points) do begin
         Points[j]:=GetTC(GetX(Triangles[j mod Length(Triangles)].x),GetY(Triangles[j mod Length(Triangles)].y),w,h,s);
       end;
       if Layer and 1=1 then
         SetRenderState(D3DRENDERSTATE_STENCILENABLE,1)
       else SetRenderState(D3DRENDERSTATE_STENCILENABLE,0);
       DXDraw.D3DDevice7.DrawPrimitive(D3DPT_TRIANGLELIST, D3DFVF_VERTEX, Points[0], Length(Triangles), 0);
       NoDrawVert:=false;
     end else if not (MapMode and (Mode=mdView)) then begin
       SetLength(Points,Length(Vertices)+1);
       for j:=0 to Length(Vertices) do begin
         Points[j]:=GetTC(GetX(Vertices[j mod Length(Vertices)].x),GetY(Vertices[j mod Length(Vertices)].y),w,h,s);
       end;
       DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Points[0], Length(Vertices)+1, 0);
       NoDrawVert:=false;
     end;
     if not NoDrawVert and HighLightVertices then begin
       //SetLength(Points,5);
       DXDraw.D3DDevice7.SetRenderState(D3DRENDERSTATE_AMBIENT, Palette[lvHighlight]);
       SetTexture(0,nil);
       for j:=0 to High(Vertices) do
         DrawVertices(Vertices[j mod Length(Vertices)]);
     end;
   end;
end;

procedure TLevel.DrawVertices(Ver: TRPoint);
var
  Points:array[0..4] of TD3DVertex;
begin
  with DXDraw.D3DDevice7 do begin
    Points[0]:=GetTC(GetX(Ver.x)-1,GetY(Ver.y)-1,1,1,0);
    Points[1]:=GetTC(GetX(Ver.x)+1,GetY(Ver.y)-1,1,1,0);
    Points[2]:=GetTC(GetX(Ver.x)+1,GetY(Ver.y)+1,1,1,0);
    Points[3]:=GetTC(GetX(Ver.x)-1,GetY(Ver.y)+1,1,1,0);
    Points[4]:=Points[0];
    DXDraw.D3DDevice7.DrawPrimitive(D3DPT_LINESTRIP, D3DFVF_VERTEX, Points[0], 5, 0);
  end;
end;

procedure TLevel.ExportBMP(FileName: TFileName);
var
  b:TBitmap;
  r:TRect;
begin
  b:=TBitmap.Create;
  b.PixelFormat:=pf24bit;
  b.Width:=Width;
  b.Height:=Height;
  r:=Bounds(0,0,Width,Height);
  b.Canvas.CopyRect(r,DXDraw.Surface.Canvas,r);
  DXDraw.Surface.Canvas.Release;
  b.SaveToFile(FileName);
  b.Free;
end;

function TLevel.FramesToTime(frames: double): integer;
begin
  {Result:=((frames-1) div 3)*10;
  case ((frames-1) mod 3) of
    0: Result:=Result+1;
    1: Result:=Result+4;
    2: Result:=Result+7;
  end;}
  Result:= round(frames * 62500 / 273) - 1;
end;

function TLevel.GetLevInfo(FileName: TFileName; out LevelName, LgrName,
  GroundName, SkyName: string):integer;
var
  f:TFileStream;
  Lev:record
    tip:array[0..4] of char;
    buf:array[0..37] of byte;
    lname:array[0..50] of char;
    lgname:array[0..15] of char;
    gname:array[0..9] of char;
    sname:array[0..9] of char;
  end;
  s:string;
begin
  f:=TFileStream.Create(Filename,fmOpenRead);
  f.Read(Lev,sizeof(Lev));
  f.Free;
  s:=Lev.tip;            
  Result:=ltAcross;
  if s='POT06' then exit;
  Result:=ltOther;
  if s<>'POT14' then exit;
  Result:=ltNormal;
  LevelName:=Lev.lname;
  LgrName:=Lev.lgname;
  GroundName:=Lev.gname;
  SkyName:=Lev.sname;
end;

function TLevel.GetOX(x: double): integer;
begin
  Result:=round(GetX(x));
end;

function TLevel.GetOY(y: double): integer;
begin
  Result:=round(GetY(y));
end;

function TLevel.GetRecInfo(FileName: TFileName;
  var LevelName: TFileName): double;
var
  f:TFileStream;
  Rec:record
    time:word;
    buf:array[0..17] of byte;
    lname:array[0..11] of char;
  end;
  events, k, j: dword;
  time, d: double;
  i: integer;
begin
  f:=TFileStream.Create(Filename,fmOpenRead);
  f.Read(Rec, sizeof(Rec));
  f.Seek(27*Rec.time + 4, soFromCurrent);
  f.Read(events, sizeof(events));
  time:= -1;
  for i:= 0 to events do begin
    f.Read(d, sizeof(double));
    f.Read(j, sizeof(dword));
    f.Read(k, sizeof(dword));
    if k = 0 then time:= d;
  end;
  f.Free;
  LevelName:=Rec.lname;
  Result:=time;
end;

function TLevel.GetRX(x: integer): double;
begin
  Result:=(x-Width/2)/Zoom+Center.x;
  if ShowGrid and SnapToGrid then
    Result:=Round(Result/GridSize)*GridSize;
end;

function TLevel.GetRY(y: integer): double;
begin
  Result:=(y-Height/2)/Zoom+Center.y;
  if ShowGrid and SnapToGrid then
    Result:=Round(Result/GridSize)*GridSize;
end;

procedure TLevel.GetSize(var w, h: double);
var
  maxx,minx,maxy,miny:double;
  i,j:integer;
begin
  maxx:=-1e32;
  minx:=1e32;
  maxy:=-1e32;
  miny:=1e32;
  for i:=0 to High(Polygons) do with Polygons[i] do
   for j:=0 to High(Vertices) do with Vertices[j] do begin
     maxx:=Max(maxx,x);
     minx:=Min(minx,x);
     maxy:=Max(maxy,y);
     miny:=Min(miny,y);
   end;
  for i:=0 to High(Objects) do with Objects[i].Pos do begin
     maxx:=Max(maxx,x);
     minx:=Min(minx,x);
     maxy:=Max(maxy,y);
     miny:=Min(miny,y);
  end;
  for i:=0 to High(Pics) do with Pics[i],Pos do begin
     if Pics[i].Name<>'' then j:=SearchPic(Pics[i].Name)
     else j:=SearchPic(Mask);
     maxx:=Max(maxx,x+PC[j].Width/50);
     minx:=Min(minx,x);
     maxy:=Max(maxy,y+PC[j].Height/50);
     miny:=Min(miny,y);
  end;
  w:=maxx-minx;
  h:=maxy-miny;
end;

function TLevel.GetTC(x, y, w, h: real;speed:real): TD3DVertex;
var
  vspeed:real;
begin
  if Speed=FastSpeed then vspeed:=0 else vspeed:=speed;
  if ZoomTextures then
  Result := MakeD3DVERTEX(
   MakeD3DVECTOR(x-Width/2, Height/2-y, 0),
   MakeD3DVector(0.0,0.0,-1.0),
   x/(w*Zoom*pz)+Center.x/(w*pz)*Speed,y/(h*Zoom*pz)+Center.y/(h*pz)*vSpeed)
  else Result := MakeD3DVERTEX(
   MakeD3DVECTOR(x-Width/2, Height/2-y, 0),
   MakeD3DVector(0.0,0.0,-1.0),
   x/(w)+Center.x*Zoom/(w)*Speed,y/(h)+Center.y*Zoom/(h)*vSpeed);
end;

function TLevel.GetTexture(FileName: TFileName;mult:boolean; var w,h:integer;f:TFileStream;Size:integer;Pos:integer): TALEImage;
var
  tmp:TUniDib;
  tmp2:TBitmap;
  tmp3:TDib;
  i,j:integer;
begin
  Tmp:=nil;
  Result.Texture:=nil;
  Result.Bmp:=nil;
  if FileName='' then begin
    UDIBLoadPCX(Tmp,f,Size,Pos);
  end else if LowerCase(FileName)='qmoto' then begin
    Result.Bmp:=TBitmap.Create;
    Result.Bmp.Width:=ALEForm.DXDIB1.DIB.Width;
    Result.Bmp.Height:=ALEForm.DXDIB1.DIB.Height;
    Result.Bmp.PixelFormat:=pf24bit;
    Result.Bmp.Canvas.Draw(0,0,ALEForm.DXDIB1.DIB);
    Result.Texture:=TDirect3DTexture2.Create(DXDraw,ALEForm.DXDIB1.DIB,false);
    exit;
  end else exit;
  Tmp2:=TBitmap.Create;
  Tmp2.Width:=Tmp.Width;
  Tmp2.Height:=Tmp.Height;
  Tmp2.PixelFormat:=pf24bit;
  if mult then Tmp2.Width:=40;
  Tmp.DIBtoScreen(Tmp2.Canvas.Handle);
  Tmp.Free;
  w:=Tmp2.Width;
  h:=Tmp2.Height;
  Tmp3:=TDib.Create;
  if mult then i:=64
  else i:=round(exp( ln(2)*(trunc(ln(Tmp2.Width)/ln(2))+1) ));
  j:=round(exp( ln(2)*(trunc(ln(Tmp2.Height)/ln(2))+1) ));
  Tmp3.SetSize(i,j,24);
  //Showmessage(IntToStr(a)+' '+IntToStr(b));
  Tmp3.Canvas.StretchDraw(Bounds(0,0,i,j),Tmp2);
  Result.Texture:=TDirect3DTexture2.Create(DXDraw,Tmp3,true);
//  Result.Texture.IsMipmap
  Result.Bmp:=Tmp2;
  Application.ProcessMessages;
end;

procedure TLevel.GetVertices(srect, drect: TRect;w,h :real; var Vertices: array of TD3DVertex);
var
  n:TD3DVector;
begin
  w:=w-1;h:=h-1;
  n:=MakeD3DVector(0.0,0.0,-1.0);
  Vertices[0] := MakeD3DVERTEX( MakeD3DVECTOR(drect.Left-Width/2, Height/2-drect.Top, 0),
   n,srect.Left/w,srect.Top/h);
  Vertices[1] := MakeD3DVERTEX( MakeD3DVECTOR(drect.Right-Width/2, Height/2-drect.Top, 0),
   n,srect.Right/w,srect.Top/h);
  Vertices[2] := MakeD3DVERTEX( MakeD3DVECTOR(drect.Left-Width/2, Height/2-drect.Bottom, 0),
   n,srect.Left/w,srect.Bottom/h);
  Vertices[3] := MakeD3DVERTEX( MakeD3DVECTOR(drect.Right-Width/2, Height/2-drect.Bottom, 0),
   n,srect.Right/w,srect.Bottom/h);
end;

function TLevel.GetX(x: double): double;
begin
  Result:=(x-Center.x)*Zoom+Width/2;
  {if Win32MajorVersion<5 then
  if abs(Result)>30000 then Result:=-30000;}
end;

function TLevel.GetY(y: double): double;
begin
  Result:=(y-Center.y)*Zoom+Height/2;
  {if Win32MajorVersion<5 then
  if abs(Result)>30000 then Result:=-30000;}
end;

procedure TLevel.IncZoom;
begin
  Zoom:=Zoom*1.5;
  Draw;
end;

procedure TLevel.InitTransText;
var
  i:integer;
begin
  for i:=0 to High(PC) do with PC[i] do
    if PC[i].Image.Texture<>nil then
    if tip<>ptTexture then begin
      Image.Texture.Surface.TransparentColor:=Image.Texture.Surface.Pixels[0,0];
      {Bitmap.Transparent:=true;
      Bitmap.TransparentMode:=tmFixed;
      Bitmap.TransparentColor:=Bitmap.Canvas.Pixels[0,0];}
    end;
  if QMoto.Texture<>nil then
    QMoto.Texture.Surface.TransparentColor:=QMoto.Texture.Surface.Pixels[0,0];
  for i:=1 to 9 do if QFood[i].Texture<>nil then
    QFood[i].Texture.Surface.TransparentColor:=QFood[i].Texture.Surface.Pixels[0,0];
  if QKiller.Texture<>nil then
    QKiller.Texture.Surface.TransparentColor:=QKiller.Texture.Surface.Pixels[0,0];
  if QExit.Texture<>nil then
    QExit.Texture.Surface.TransparentColor:=QExit.Texture.Surface.Pixels[0,0];
end;

procedure TLevel.InitUndoRedoVisible;
begin
  with ALEForm do begin
    if CurCopy>=0 then Undo.Enabled:=true
    else Undo.Enabled:=false;
    if CurCopy<Length(Backups)-1 then Redo.Enabled:=true
    else Redo.Enabled:=false;
  end;
end;

function TLevel.Intersect(p1, p2, r1, r2: TRPoint;
  var t: TRPoint): boolean;
var
  m,n,t1,t2,t3:real;
begin
//  m*(p2.x-p1.x)+p1.x=n*(r2.x-r1.x)+r1.x;
//  m*(p2.y-p1.y)+p1.y=n*(r2.y-r1.y)+r1.y;
  t1:=(p2.x-p1.x)*(r2.y-r1.y)-(p2.y-p1.y)*(r2.x-r1.x);
  t2:=(p1.y-r1.y)*(r2.x-r1.x)-(p1.x-r1.x)*(r2.y-r1.y);
  t3:=(r1.x-p1.x)*(p2.y-p1.y)-(r1.y-p1.y)*(p2.x-p1.x);
  Result:=false;
  if t1=0 then begin
   if (t2<>0) or (t3<>0) then Result:=false
   else if (p1.x<>p2.x) and (r1.x<>r2.x) then begin
    if (r1.x-p1.x)*(r2.x-p1.x)<=0 then begin
      Result:=true;
      t:=p1;
    end;
    if (r1.x-p2.x)*(r2.x-p2.x)<=0 then begin
      Result:=true;
      t:=p2;
    end;
    if (p1.x-r1.x)*(p2.x-r1.x)<=0 then begin
      Result:=true;
      t:=r1;
    end;
   end else begin
    if (r1.y-p1.y)*(r2.y-p1.y)<=0 then begin
      Result:=true;
      t:=p1;
    end;
    if (r1.y-p2.y)*(r2.y-p2.y)<=0 then begin
      Result:=true;
      t:=p2;
    end;
    if (p1.y-r1.y)*(p2.y-r1.y)<=0 then begin
      Result:=true;
      t:=r1;
    end;
   end
  end else begin
    m:=t2/t1;
    n:=t3/t1;
    if (m<=1) and (m>=0) and (n<=1) and (n>=0) then begin
      Result:=true;
      t.x:=(p2.x-p1.x)*m+p1.x;
      t.y:=(p2.y-p1.y)*m+p1.y;
    end;
  end;
end;

function TLevel.IsImageHere(const Tex: TALEImage; x, y: integer; FramedType: integer): boolean;
begin
  if Tex.Bmp = nil then Result:=false
  else if FramedType=ftPicture then begin
    if (abs(x - 0) < RNear) or (abs(x - Tex.Bmp.Width) < RNear) or
       (abs(x - 0) < RNear) or (abs(x - Tex.Bmp.Width) < RNear) then
       Result:=true
    else
       Result:=false;
  end else if FramedType=ftObject then begin
    if ( abs(sqrt(sqr(x-20) + sqr(y-20)) - 20) < RNear) then
       Result:=true
    else
       Result:=false;
  end else
    if (x < 0) or (y < 0) or (x >= Tex.Bmp.Width) or (y >= Tex.Bmp.Height) then Result:=false
  else
     Result:= (Tex.Bmp.Canvas.Pixels[x,y] <> Tex.Bmp.Canvas.Pixels[0,0]);
end;

procedure TLevel.KeyPressed(key: word);
begin
  if (Tool<>nil) and (Mode=mdEdit) then begin
    Tool.KeyPressed(key);
    if not ALEForm.Timer1.Enabled then Draw;
  end;
end;

procedure TLevel.LoadBackGroundPic(FileName: TFileName);
var
  tmp2:TGraphic;
  tmp3:TDib;
  i,j:integer;
begin
  if not FileExists(FileName) then begin
    AddMessage(Format(MessageString[10],[ExtractFileName(FileName)]),iWarning);
    exit;
  end;
  if (LowerCase(ExtractFileExt(FileName))='.bmp') or
     (LowerCase(ExtractFileExt(FileName))='.dib') then
    Tmp2:=TBitmap.Create else
  if LowerCase(ExtractFileExt(FileName))='.ico' then
    Tmp2:=TIcon.Create else
  if (LowerCase(ExtractFileExt(FileName))='.jpg') or
     (LowerCase(ExtractFileExt(FileName))='.jpeg') then
    Tmp2:=TJPEGImage.Create else exit;
  Tmp2.LoadFromFile(FileName);
  with BGPicture do begin
    srect.Left:=0;
    srect.Top:=0;
    srect.Right:=Tmp2.Width-1;
    srect.Bottom:=Tmp2.Height-1;
    Tmp3:=TDib.Create;
    i:=round(exp( ln(2)*(trunc(ln(Tmp2.Width)/ln(2))+1) ));
    j:=round(exp( ln(2)*(trunc(ln(Tmp2.Height)/ln(2))+1) ));
    Tmp3.SetSize(i,j,24);
    //Tmp3.Canvas.Brush.Color:=Tmp2.Canvas.Pixels[0,0];
    Tmp3.Canvas.FillRect(Tmp3.Canvas.ClipRect);
    Tmp3.Canvas.Draw(0,0,Tmp2);
    BGPicture.Texture:=TDirect3DTexture2.Create(DXDraw,Tmp3,true);
    x1:=Center.x-Tmp2.Width/Zoom/2;
    x2:=Center.x+Tmp2.Width/Zoom/2;
    y1:=Center.y-Tmp2.Height/Zoom/2;
    y2:=Center.y+Tmp2.Height/Zoom/2;
    Tmp2.Free;
  end;
end;

procedure TLevel.LoadPictures(pPC:TPC);
const
  step=12;
var
  i,j,ip:integer;
  w,h:integer;
//
  f:TFileStream;
  mas:array of
   record
     dis,clip,unn:dword;
     tip:string[4];
   end;
  id:string[5];
  nofp,nofall,dw:dword;
  sname:string[12];
  names:array of string[10];
  NLgr:string;
  CurText:TALEImage;
  OPos:dword;
begin
  if DXDraw=nil then exit;
  LoadingPictures:=true;
  if pPC<>nil then begin
    PC:=pPC;
    exit;
  end;
  SetCurrentDir(ExtractFileDir(ParamStr(0)));
  for i:=0 to High(PC) do begin
    PC[i].Image.Texture.Free;
    PC[i].Image.Texture:=nil;
    PC[i].Image.Bmp.Free;
    PC[i].Image.Bmp:=nil;
  end;
  SetLength(PC,0);
  QExit.Texture.Free; 
  QExit.Texture:=nil;
  QExit.Bmp.Free;
  QExit.Bmp:=nil;
  for i:=1 to 9 do begin
   QFood[i].Texture.Free;
   QFood[i].Texture:=nil;
   QFood[i].Bmp.Free;
   QFood[i].Bmp:=nil;
  end;
  QKiller.Texture.Free;
  QKiller.Texture:=nil;
  QKiller.Bmp.Free;
  QKiller.Bmp:=nil;
  {QMoto.Texture.Free;
  QMoto.Texture:=nil;}
//---
  NLgr:=CurDir+'\LGR\'+fLGR+'.lgr';
  if LowerCase(fLGR)='default' then NLgr:=DefaultLGR;
  //NLgr:='Lgr\'+Lgr;
  f:=nil;
  nofp:=0;
  MapCLoaded:=false;
  if FileExists(NLgr) then
  try
    f:=TFileStream.Create(NLgr,fmOpenRead);
    f.Read(id[1],5);
    id[0]:=#5;
    if id<>'LGR12' then begin
      AddMessage(Format(MessageString[11],[Lgr+'.lgr']),iWarning);
      exit;
    end;
    f.Read(nofall,4);
    f.Read(dw,4);
    f.Read(nofp,4);
    SetLength(names,nofp);
    for i:=0 to nofp-1 do begin
     SetLength(names[i],10);
     f.Read(names[i,1],10);
     j:=1;
     while j<=12 do begin
       if names[i,j]=#0 then break;
       inc(j);
     end;
     SetLength(names[i],j-1);
    end;
    SetLength(Mas,nofp);
    for i:=0 to nofp-1 do begin
     SetLength(mas[i].tip,4);
     f.Read(mas[i].tip[1],4);
    end;
    for i:=0 to nofp-1 do
     f.Read(mas[i].dis,4);
    for i:=0 to nofp-1 do
     f.Read(mas[i].clip,4);
    for i:=0 to nofp-1 do
     f.Read(mas[i].unn,4);

    ip:=0;
    SetLength(PC,StdNOP);
    OPos:=f.Position;
    dw:=0;
    for i:=0 to nofall-1 do begin
      f.Seek(OPos+dw,soFromBeginning);
      SetLength(sname,12);
      f.Read(sname[1],12);
      f.Read(dw,4);
      f.Read(dw,4);
      f.Read(dw,4);
      OPos:=f.Position;
      j:=1;
      while j<=12 do begin
        if sname[j]=#0 then break;
        inc(j);
      end;
      SetLength(sname,j-1);
      sname:=LowerCase(sname);
      if (sname='qcolors.pcx') then CurText:=GetTexture('',false,w,h,f,dw,OPos)
      else if (sname='qexit.pcx') or (sname='qkiller.pcx') then
        CurText:=GetTexture('',true,w,h,f,dw,OPos)
      else begin
        j:=1;
        while (j<=9) do begin
          if sname='qfood'+IntToStr(j)+'.pcx' then break;
          inc(j);
        end;
        if j>9 then begin
          if (sname[1]<>'q') then CurText:=GetTexture('',false,w,h,f,dw,OPos)
        end else CurText:=GetTexture('',true,w,h,f,dw,OPos);
      end;
      if sname='qexit.pcx' then QExit:=CurText;
      if sname='qkiller.pcx' then QKiller:=CurText;
      for j:=1 to 9 do
       if sname='qfood'+IntToStr(j)+'.pcx' then QFood[j]:=CurText;
      //Çàãðóçêà öâåòîâ êàðòû
      if sname='qcolors.pcx' then begin
        for j:=0 to 8 do
          MapColors[j]:=CurText.Bmp.Canvas.Pixels[2,2+j*step];
          MapCLoaded:=true;
        CurText.Texture.Free;
        CurText.Bmp.Free;
        MapCLoaded:=true;
      end;
      {if (sname[1]='q') and (sname<>'qexit.pcx') and (sname<>'qkiller.pcx')
       and (sname<>'qcolors.pcx') and (Copy(sname,0,5)<>'qfood') then
       begin
         CurText.Texture.Free;
         CurText.Bmp.Free;
       end;}
      if sname[1]='q' then continue;
      SetLength(sname,Pos('.',sname)-1);
      PC[ip].Name:=sname;
      PC[ip].Image:=CurText;
      PC[ip].Width:=PC[ip].Image.Bmp.Width;
      PC[ip].Height:=PC[ip].Image.Bmp.Height;
      inc(ip);
      if ip>High(PC) then SetLength(PC,ip+1);
    end;
    if ip<High(PC)+1 then SetLength(PC,ip);
  except
    f.Free;
    AddMessage(Format(MessageString[13],[Lgr+'.lgr']),iWarning);
  end;
  f.Free;
///----
  if not MapCLoaded then AddMessage(MessageString[12], iWarning);
  if nofp>0 then
  for i:=0 to nofp-1 do begin
    j:=SearchPic(names[i]);
    if j<0 then continue;
    PC[j].Distance:=mas[i].dis;
    PC[j].Clipping:=mas[i].clip;
    case mas[i].tip[1] of
      'd':PC[j].tip:=ptPicture;
      'e':PC[j].tip:=ptTexture;
      'f':PC[j].tip:=ptMask;
    end;
  end;
  LoadingPictures:=false;
end;

procedure TLevel.MouseDown(Shift: TShiftState;nx, ny: integer);
begin
  if (Tool<>nil) and (Mode=mdEdit) then begin
    Tool.MouseDown(Shift,nx,ny);
    if not ALEForm.Timer1.Enabled then Draw;
  end;
end;

procedure TLevel.MouseMove(Shift: TShiftState;nx, ny: integer);
begin
  if (Tool<>nil) and (Mode=mdEdit) then begin
    Tool.MouseMove(Shift,nx,ny);
  end;
  if not ALEForm.Timer1.Enabled then Draw;
end;

procedure TLevel.MouseUp(Shift: TShiftState;nx, ny: integer);
begin
  if (Tool<>nil) and (Mode=mdEdit) then begin
    Tool.MouseUp(Shift,nx,ny);
    if not ALEForm.Timer1.Enabled then Draw;
  end;
end;

procedure TLevel.MoveCenter(dx, dy: integer);
begin
  Center.x:=Center.x+dx/Zoom;
  Center.y:=Center.y+dy/Zoom;
  Draw;
end;

procedure TLevel.New;
const
  ww=24;
  hh=5;
var
  p:TRPoint;

begin
  if PromtOnSave=IDCANCEL then exit;
  if (Tool is TSelectTool) then (Tool as TSelectTool).ClearSelection;
  Name:='Unnamed';
  Ground:='ground';
  Sky:='sky';
  LGR:='default';
  SetLength(Polygons,1);
  SetLength(Polygons[0].Vertices,4);
  with Polygons[0] do begin
     Vertices[0].x:=-ww;
     Vertices[0].y:=-hh;
     Vertices[1].x:=ww;
     Vertices[1].y:=-hh;
     Vertices[2].x:=ww;
     Vertices[2].y:=hh;
     Vertices[3].x:=-ww;
     Vertices[3].y:=hh;
  end;
  SetLength(Objects,2);
  Objects[0].typ:=4;
  Objects[0].Pos.x:=2;
  Objects[0].Pos.y:=3.5;
  Objects[1].typ:=1;
  Objects[1].Pos.x:=-2;
  Objects[1].Pos.y:=3.5;
  SetLength(Pics,0);
  CurrentLevel:='';
  ZoomFill;
  Modified:=false;
  ClearBestTimes;
  //ALEForm.SpeedButton5.Down:=true;
  if (Mode=mdView) and FillPolygons then
    TopChecked:=CheckTopology(p,true)
  else TopChecked:=CheckTopology(p,false);
end;

procedure TLevel.Normalize(var V: TRPoint);
var
  r:double;
begin
  r:=sqrt(v.x*v.x+v.y*v.y);
  if r<>0 then begin
    v.x:=v.x/r;
    v.y:=v.y/r;
  end;
end;

procedure TLevel.Open(Filename: TFileName);
var
  f:TFileStream;
  id:string[5];
  dw:dword;
  d:double;
  i,j:integer;
  p:TRPoint;
  iss,ise:boolean;
  tmp:string[16];
  t2:^dword;
  rtime:double;
  num:integer;
  lname:string;  
  LevelTime:string;
  RecTime:string;

begin
  if PromtOnSave=IDCANCEL then exit;
  if Filename='' then begin
    New;
    exit;
  end;
  RecTime:='';
  if LowerCase(ExtractFileExt(Filename))='.rec' then begin
    rtime:=GetRecInfo(FileName,FileName);
    RecTime:=Format(MessageString[62],[TimeToStr(FramesToTime(rtime))]);
    FileName:=CurDir+'\Lev\'+FileName;
    {if not FileExists(Filename) then begin
      AddMessage(Format(MessageString[13],[Filename]),iWarning);
      New;
      exit;
    end;}
  end;
  if not FileExists(Filename) then begin
    num:=-1;
    lname:=LowerCase(ExtractFileName(FileName));
    if Copy(lName,1,6)='qwquu0' then
      num:=StrToIntDef(Copy(lName,7,2),-1);
    if num>=0 then begin
      lName:='Internal #';
      if num<=9 then lName:=lName+' ';
      lName:=lName+IntToStr(num);
      FileName:=lname;
    end;
    AddMessage(Format(MessageString[13],[Filename]),iWarning);
    if Length(Polygons)=0 then New; 
    if RecTime<>'' then AddMessage(RecTime,iInform);
    exit;
  end;
  f:=TFileStream.Create(Filename,fmOpenRead);
  with f do begin
    Read(id[1],5);
    id[0]:=#5;
    if id<>'POT14' then begin
      if id='POT06' then
        AddMessage(MessageString[14],iInform)
      else AddMessage(Format(MessageString[15],[FileName]),iWarning);
      f.Free;
      New;
      CurrentLevel:=Filename;
      Draw; 
      if RecTime<>'' then AddMessage(RecTime,iInform);
      exit;
    end;
    Read(dw,2);
    Read(dw,4);
    for i:=0 to 3 do
     Read(d,8);
    Read(name[1],51);
    i:=1;while (i<51) and (name[i]<>#0) do inc(i);name[0]:=chr(i-1);
    //name:=LowerCase(name);
    Read(tmp[1],16);
    i:=1;while (i<16) and (tmp[i]<>#0) do inc(i);tmp[0]:=chr(i-1);
    tmp:=LowerCase(tmp);
    Read(Ground[1],10);
    i:=1;while (i<10) and (Ground[i]<>#0) do inc(i);Ground[0]:=chr(i-1);
    Ground:=LowerCase(Ground);
    Read(Sky[1],10);
    i:=1;while (i<10) and (Sky[i]<>#0) do inc(i);Sky[0]:=chr(i-1);
    Sky:=LowerCase(Sky);

    Read(d,8);
    SetLength(Polygons,round(d-0.4643643));
    for i:=0 to Length(Polygons)-1 do with Polygons[i] do begin
      Read(Grass,4);
      Read(dw,4);
      SetLength(Vertices,dw);
      for j:=0 to dw-1 do Read(Vertices[j],16);
    end;
    Read(d,8);
    SetLength(Objects,round(d-0.4643643));
    for i:=0 to Length(Objects)-1 do begin
      Read(Objects[i],16);
      Read(Objects[i].typ,12);
    end;
    Read(d,8);
    SetLength(Pics,round(d-0.2345672));
    for i:=0 to Length(Pics)-1 do with Pics[i] do begin
      Read(Name[1],10);
      j:=1;while (j<10) and (Name[j]<>#0) do inc(j);Name[0]:=chr(j-1);
      Name:=LowerCase(Name);
      Read(Texture[1],10);
      j:=1;while (j<10) and (Texture[j]<>#0) do inc(j);Texture[0]:=chr(j-1);
      Texture:=LowerCase(Texture);
      Read(Mask[1],10);
      j:=1;while (j<10) and (Mask[j]<>#0) do inc(j);Mask[0]:=chr(j-1);
      Mask:=LowerCase(Mask);
      Read(Pos,16);
      Read(Distance,4);
      Read(Clipping,4);
    end;
    if Lgr<>tmp then Lgr:=tmp
    else CheckChangingLGR;
    if SearchPic(Sky)<0 then Sky:='sky';
    if SearchPic(Ground)<0 then Ground:='ground';
    Read(dw,4);
    Read(BestTimes,688);
    for i:=0 to 171 do begin
      t2:=@BestTimes[i*4];
//      if i=0 then ShowMessage(IntToHex(t2^,8));
      t2^:=t2^ xor empty[i];
      //BestTimes[i]:=BestTimes[i] xor ((empty[i shr 2] shr ((i and 3)*8)) and $ff);
    end
  end;
  f.Free;
  CurrentLevel:=Filename;
  ZoomFill;
  if DXDraw<>nil then begin
    if (Mode=mdEdit) or not FillPolygons then
      TopChecked:=false
    else TopChecked:=CheckTopology(p,true);
    SortPictures;
  end;
  Modified:=false;
  iss:=false;
  ise:=false;
  for i:=0 to High(Objects) do with Objects[i] do
  case Objects[i].typ of
    1:ise:=true;
    2,3: ;
    4:iss:=true;
    else typ:=2;
  end;
  if not iss then begin
    AddMessage(MessageString[16],iInform);
    SetLength(Objects,Length(Objects)+1);
    with Objects[High(Objects)] do begin
      typ:=4;
      Pos.x:=2;
      Pos.y:=3.5;
    end;
  end;
  if not ise then begin
    AddMessage(MessageString[17],iInform);
    SetLength(Objects,Length(Objects)+1);
    with Objects[High(Objects)] do begin
      typ:=1;
      Pos.x:=-2;
      Pos.y:=3.5;
    end;
  end;
  if Mode=mdEdit then ALEForm.AddOpened(CurrentLevel);
  if (Tool is TSelectTool) then (Tool as TSelectTool).ClearSelection;
  Draw;
  if ShowInfo then begin
    if (PInteger(@BestTimes[0]))^>0 then
      LevelTime:=StatForm.GetNicks(0,false,true)+' '+StatForm.GetTime(0,false)
    else LevelTime:=MessageString[66];
    AddMessage(Format(MessageString[65],[Name,LevelTime]),iInform);
  end;
  if RecTime<>'' then AddMessage(RecTime,iInform);
end;

function TLevel.PromtOnSave: integer;
var
  Answer:integer;
begin
  if Modified then begin
    Answer:=MessageBox(0,PAnsiChar(MessageString[18]),'ALE',MB_YESNOCANCEL);
    if Answer=IDYES then
    if CurrentLevel<>'' then Save(CurrentLevel,false,false)
    else if ALEForm.SaveDialog1.Execute then Save(ALEForm.SaveDialog1.FileName,false,false)
    else Answer:=IDCANCEL;
  end else Answer:=IDYES;
  Result:=Answer;
end;

function TLevel.PtInPol(p: TRPoint; pol: PPolygon): boolean;
var
  ni,i:integer;
  k1,k2:double;
begin
  ni:=0;
  with pol^ do
  for i:=0 to High(Vertices) do begin
    k1:=Vertices[i].x-p.x;
    k2:=-(Vertices[(i+1) mod Length(Vertices)].x-p.x);
    if k1=0 then k1:=1e-10;
    if k2=0 then k2:=-1e-10;
    //if k1*k2=0 then ShowMessage('Yo2');
    //if k1<0 then begin k1:=-k1;k2:=-k2 end;
    if (k1*k2>=0) and (k1<>0) and
      (Vertices[i].y*k2/(k2+k1)+
       Vertices[(i+1) mod Length(Vertices)].y*k1/(k2+k1)
       <p.y)
    then inc(ni);
  end;
  Result:=odd(ni);
end;

procedure TLevel.Redo;
begin
  if CurCopy<Length(Backups)-1 then begin
    inc(CurCopy);
    SwapBackup(CurCopy);
    Draw;
    InitUndoRedoVisible;  
    ALEForm.ToolButton3.Enabled:=true;
    TopChecked:=false;    
    fModified:=true;
    ALEForm.StatusBar1.Panels[1].Text:=MessageString[21];
  end;
end;

procedure TLevel.Save(Filename: TFileName; Locked: boolean; OnlySelected: boolean);
const
  id:string='POT14';
var
  f:TFileStream;
  psum,osum,picsum,sum,d:double;
  dw:dword;
  i,j:integer;
  Vertex:TRPoint;
  len,cnt:integer;
  flags:array of integer;
  wasstart,wasexit:boolean;
begin
  asm FINIT end;
//Ïðîâåðêà îðèåíòàöèè
  if not TopChecked then
  if not CheckTopology(Vertex, false) then AddMessage(MessageString[19],iWarning);
  //--------------------
  if not FileExists(Filename) then
    f:=TFileStream.Create(Filename,fmCreate)
  else
    f:=TFileStream.Create(Filename,fmOpenWrite);
  with f do begin
    Write(id[1],5);
    randomize;
    dw:=random(maxint);
    Write(dw,2);
    Write(dw,4);
//Calculate control sums
    psum:=0;
    for i:=0 to High(Polygons) do with Polygons[i] do
     for j:=0 to High(Vertices) do with Vertices[j] do
     psum:=psum+x+y;
    osum:=0;
    for i:=0 to High(Objects) do with Objects[i] do
     osum:=osum+Pos.x+Pos.y+typ;
    picsum:=0;
    for i:=0 to High(Pics) do with Pics[i] do
     picsum:=picsum+Pos.x+Pos.y;
    sum:=(psum+osum+picsum)*3247.764325643;
    Write(sum,8);
    d:=random(5871)+11877-sum;
    Write(d,8);
    d:=random(5871)+11877-sum;
    Write(d,8);
    if Locked then
      d:=random(6310)+23090-sum
    else d:=random(6102)+12112-sum;
    Write(d,8);
//--------------------------------
    name[Length(name)+1]:=#0;
    Write(name[1],51);
    fLGR:=LowerCase(fLGR);
    fLGR[Length(fLGR)+1]:=#0;
    Write(fLGR[1],16);
    Ground:=LowerCase(Ground);
    Ground[Length(Ground)+1]:=#0;
    Write(Ground[1],10);
    Sky:=LowerCase(Sky);
    Sky[Length(Sky)+1]:=#0;
    Write(Sky[1],10);
//--------------------------------
    if OnlySelected then begin
      len:=0;
      SetLength(flags,Length(Polygons));
      for i:=0 to High(Polygons) do begin
        cnt:=0;
        for j:=0 to High(Polygons[i].Vertices) do
          if Polygons[i].Vertices[j].Selected then
            inc(cnt);
        flags[i]:=cnt;
        if cnt>=3 then inc(len);
      end;
    end else len:=Length(Polygons);
    d:=len+0.4643643;
    Write(d,8);
    for i:=0 to High(Polygons) do with Polygons[i] do
    if (not OnlySelected) or (flags[i]>=3) then begin
      Write(Grass,4);
      if OnlySelected then dw:=flags[i]
      else dw:=Length(Vertices);  
      Write(dw,4);
      for j:=0 to High(Vertices) do
        if (not OnlySelected) or (Vertices[j].Selected) then
          Write(Vertices[j],16);
    end;
    if OnlySelected then begin
      len:=0;
      for i:=0 to High(Objects) do
        if Objects[i].Pos.Selected then
          inc(len);
    end else len:=Length(Objects);
    d:=len+0.4643643;
    Write(d,8);
    wasstart:=false;
    wasexit:=false;
    for i:=0 to Length(Objects)-1 do
    if (not OnlySelected) or (Objects[i].Pos.Selected) then begin
      Write(Objects[i],16);
      Write(Objects[i].typ,12);
      if Objects[i].typ=4 then wasstart:=true;
      if Objects[i].typ=1 then wasexit:=true;
    end;
    if not wasstart then begin
      AddMessage(MessageString[16],iInform);
      SetLength(Objects,Length(Objects)+1);
      with Objects[High(Objects)] do begin
        typ:=4;
        Pos.x:=2;
        Pos.y:=3.5;
      end;
    end;
    if not wasexit then begin
      AddMessage(MessageString[17],iInform);
      SetLength(Objects,Length(Objects)+1);
      with Objects[High(Objects)] do begin
        typ:=1;
        Pos.x:=-2;
        Pos.y:=3.5;
      end;
    end;
    if OnlySelected then begin
      len:=0;
      for i:=0 to High(Pics) do
        if Pics[i].Pos.Selected then
          inc(len);
    end else len:=Length(Pics);
    d:=len+0.2345672;
    Write(d,8);
    for i:=0 to Length(Pics)-1 do with Pics[i] do
    if (not OnlySelected) or (Pics[i].Pos.Selected) then begin
      name[Length(name)+1]:=#0;
      Name:=LowerCase(Name);
      Write(Name[1],10);
      Texture[Length(Texture)+1]:=#0;
      Texture:=LowerCase(Texture);
      Write(Texture[1],10);
      Mask[Length(Mask)+1]:=#0;
      Mask:=LowerCase(Mask);
      Write(Mask[1],10);
      Write(Pos,16);
      Write(Distance,4);
      Write(Clipping,4);
    end;
    dw:=$0067103A;
    Write(dw,4);
    for i:=0 to 171 do
     Write(empty[i],4);
    dw:=$00845D52;
    Write(dw,4);
  end;
  f.Free;
  if not OnlySelected then begin
    CurrentLevel:=Filename;
    Modified:=false;
    ClearBestTimes;
  end;
end;

function TLevel.SearchPic(name: string): integer;
var i:integer;
begin
  Result:=-1;
  if Name='' then Exit;
  if Length(PC)=0 then exit;
  i:=0;
  while (PC[i].Name<>Name) and (i<High(PC)) do inc(i);
  if PC[i].Name=Name then Result:=i;
end;

procedure TLevel.SendToBack(npol: integer);
var
  Pol:TPolygon;
  i:integer;
begin
  if npol=High(Polygons) then exit;
  Modified:=true;
  Pol:=Polygons[npol];
  for i:=npol to High(Polygons)-1 do Polygons[i]:=Polygons[i+1];
  Polygons[High(Polygons)]:=Pol;
end;

procedure TLevel.SetAnimIndex(const Value: integer);
begin
  FAnimIndex:=Value;
//  if AnimNew then ALEForm.ToolButton1.ImageIndex:=14+((FAnimIndex+25) mod 50);
end;

procedure TLevel.SetCurLevel(const Value: TFileName);
begin
  fCurrentLevel:=Value;
  if fCurrentLevel<>'' then
    ALEForm.Caption:='Advanced Level Editor - '+fCurrentLevel
  else ALEForm.Caption:='Advanced Level Editor - '+MessageString[20];
end;

procedure TLevel.SetFillPolygons(const Value: boolean);
var
  p:TRPoint;
begin
  if fFillPolygons=Value then exit;
  fFillPolygons:=Value;
  if FillPolygons and (Mode=mdView) then CheckTopology(p,true);
end;

procedure TLevel.SetLGR(const Value: ShortString);
var
  reallgr:string;
begin
  if FLGR=Value then exit;
  //if DelOld then DeleteFile()
//  UnPackLgr(Value);
  fLgr:=Value;
  reallgr:=CurDir+'\LGR\'+fLGR+'.lgr';
  if LowerCase(fLGR)='default' then reallgr:=DefaultLGR;
  if not FileExists(reallgr) then begin
    AddMessage(Format(MessageString[13],[fLgr+'.lgr']),iWarning);
    if LowerCase(fLGR)<>'default' then begin
      fLGR:='default';
      if not FileExists(DefaultLGR) then
        AddMessage(Format(MessageString[13],[fLgr+'.lgr']),iWarning);
    end;
  end;
  LoadPictures(nil);
  if DXDraw<>nil then begin
    CheckChangingLGR;
    if DXDraw.Initialized then InitTransText;
  end;
  //if PictureForm<>nil then PictureForm.ReloadLGR;
end;

procedure TLevel.SetMode(const Value: integer);
var
  p:TRPoint;
begin
  if fMode=Value then exit;
  if fMode=mdEdit then begin
    {if PromtOnSave=IDCANCEL then begin
      fMode:=Value;
      exit;
    end else begin}
      //Modified:=false;
    if FillPolygons then CheckTopology(p,true);
    ALEForm.PaintBox1.Cursor:=crHand;
  end else
   if not ALEForm.SpeedButton1.Down then
    ALEForm.PaintBox1.Cursor:=crDefault;
  fMode:=Value;
  if fMode=mdEdit then
   ALEForm.AddOpened(CurrentLevel);
//  ZoomFill;
//  Draw;
end;

procedure TLevel.SetModified(const Value: boolean);
var
  i:integer;
begin
  fModified:=Value;
  if fModified then
    ALEForm.StatusBar1.Panels[1].Text:=MessageString[21]
  else ALEForm.StatusBar1.Panels[1].Text:='';
  if Modified or (CurrentLevel='') then ALEForm.ToolButton3.Enabled:=true
  else ALEForm.ToolButton3.Enabled:=false;
  if fModified then begin
    inc(CurCopy);
    for i:=CurCopy+1 to Length(Backups)-1 do Backups[i].Free;
    SetLength(Backups,CurCopy+1);
    Backups[CurCopy]:=TBackup.Create;
    Backups[CurCopy].Polygons:=Copy(Polygons);
    for i:=0 to High(Polygons) do
      Backups[CurCopy].Polygons[i].Vertices:=Copy(Polygons[i].Vertices);
    Backups[CurCopy].Objects:=Copy(Objects);
    Backups[CurCopy].Pics:=Copy(Pics);
    Backups[CurCopy].name:=name;
    Backups[CurCopy].LGR:=LGR;
    Backups[CurCopy].Ground:=Ground;
    Backups[CurCopy].Sky:=Sky;
    ClearBestTimes;   
    TopChecked:=false;
  end;
  InitUndoRedoVisible;
end;

procedure TLevel.SetSize(w, h: integer);
begin
  if (w=Width) and (h=height) then exit;
  Width:=w;
  Height:=h;
  InitTransText;  
{  Bitmap.Width:=Width;
  Bitmap.Height:=Height;}
  //DXDraw.Surface.SetSize(w,h);
end;

procedure TLevel.SetTopChecked(const Value: boolean);
begin
  FTopChecked := Value;
  if Value=false then FullTopChecked:=false;
end;

procedure TLevel.SetZoom(const Value: double);
begin
  asm finit end;
  fZoom:=Value;
  if fZoom<1 then fZoom:=1;
  if fZoom>1e+3 then fZoom:=1e+3;
  ALEForm.StatusBar1.Panels[0].Text:=MessageString[22]+' : '+FloatToStr(fZoom);
end;

procedure TLevel.SortPictures;
var
  i,j:integer;
  Picture:TEPicture;
  sorted:boolean;
begin
  for i:=0 to High(Pics)-1 do begin
    sorted:=true;
    for j:=0 to High(Pics)-i-1 do
     if Pics[j].Distance<Pics[j+1].Distance then begin
      Picture:=Pics[j+1];
      Pics[j+1]:=Pics[j];
      Pics[j]:=Picture;
      sorted:=false;
     end;
    if sorted then exit;
  end;
end;

function TLevel.StatusLine(p: TPoint): string;
const
  clip:string='UGS';
var
  npol,n,tp:integer;
  pr:TRPoint;
  sng:boolean;

function Gr(grav:integer):string;
begin
  case grav of
    0:Result:=MessageString[23];
    1:Result:=MessageString[24];
    2:Result:=MessageString[25];
    3:Result:=MessageString[26];
    4:Result:=MessageString[27];
  end;
end;

begin
  sng:=SnapToGrid;
  SnapToGrid:=false;
  pr.x:=GetRX(p.x);
  pr.y:=GetRY(p.y);
  SnapToGrid:=sng;
  WhatHere(pr,npol,n,tp);
  case tp of
    tpNone:   Result:='';
    tpVertex: if ShowPolygons and (ShowGrass or (Polygons[npol].Grass=0)) then
      Result:=Format(MessageString[28],[n,npol]);
    tpObject: if ShowObjects then
      case Objects[n].typ of
        1:Result:=MessageString[29];
        2:Result:=Format(MessageString[30],[Objects[n].AnimNumber+1,Gr(Objects[n].TofF)]);
        3:Result:=MessageString[31];
        4:Result:=MessageString[32];
      end;
    tpPicture:with Pics[n] do begin
      if Name<>'' then begin
        if ShowPictures or Framepictures then
         Result:=Format(MessageString[33],[Pics[n].Name,Distance])+' '+clip[Clipping+1]
      end else
       if ShowTextures then
        Result:=Format(MessageString[34],[Pics[n].Texture,Pics[n].Mask,Distance])+clip[Clipping+1];
    end;
    tpPolygon: if ShowPolygons and (ShowGrass or (Polygons[npol].Grass=0)) then
      Result:=Format(MessageString[42],[n,npol]);
  end;
end;

procedure TLevel.SwapBackup(index: integer);
var
  tmp:TBackup;
begin
  tmp:=TBackup.Create;
  tmp.Polygons:=Backups[index].Polygons;
  tmp.Objects:=Backups[index].Objects;
  tmp.Pics:=Backups[index].Pics;
  tmp.name:=Backups[index].name;
  tmp.LGR:=Backups[index].LGR;
  tmp.Ground:=Backups[index].Ground;
  tmp.Sky:=Backups[index].Sky;
  //
  Backups[index].Polygons:=Polygons;
  Backups[index].Objects:=Objects;
  Backups[index].Pics:=Pics;
  Backups[index].name:=name;
  Backups[index].LGR:=LGR;
  Backups[index].Ground:=Ground;
  Backups[index].Sky:=Sky;
  //
  Polygons:=tmp.Polygons;
  Objects:=tmp.Objects;
  Pics:=tmp.Pics;
  name:=tmp.name;
  LGR:=tmp.LGR;
  Ground:=tmp.Ground;
  Sky:=tmp.Sky;
  tmp.Free;
end;

function TLevel.SwapColors(t: Cardinal): Cardinal;
var
  t2:Cardinal;
begin
  t2:=t and $ff;
  t:=(t and $ffffff00) or ((t shr 16) and $ff);
  t:=(t and $ff00ffff) or (t2 shl 16);
  Result:=t;
end;

function TLevel.TimeToStr(time: integer): string;
var
  mn,ss:integer;
  tm:string;
begin
  mn:=time;
  ss:=mn mod 100;
  if ss<10 then tm:=':0' else tm:=':';
  tm:=tm+IntToStr(ss);
  mn:=mn div 100;
  ss:=mn mod 60;
  tm:=IntToStr(ss)+tm;
  if ss<10 then tm:=':0'+tm else tm:=':'+tm;
  mn:=mn div 60;
  tm:=IntToStr(mn)+tm;
  if mn<10 then tm:='0'+tm;
  Result:=tm;
end;

procedure TLevel.Undo;
begin
  if CurCopy>=0 then begin
    SwapBackup(CurCopy);
    Draw;
    dec(CurCopy);
    InitUndoRedoVisible;
    ALEForm.ToolButton3.Enabled:=true; 
    TopChecked:=false;
    fModified:=true;
    ALEForm.StatusBar1.Panels[1].Text:=MessageString[21];
  end;
end;
(*
procedure TLevel.UnPackLgr(NLgr: string);
var
  f,f2:TFileStream;
  ft:TextFile;
  mas:array of
   record
     dis,clip,unn:dword;
     tip:string[4];
   end;
  i,j:integer;
  id:string[5];
  nofp,nofall,dw:dword;
  name:string[12];
  names:array of string[10];
  b:byte;
begin
  SetCurrentDir(ExtractFileDir(ParamStr(0)));
  NLgr:='Lgr\'+NLgr;
  if DirectoryExists(NLgr) then exit;
  if not FileExists(CurDir+'\'+NLgr+'.lgr') then exit;
  f:=nil;
  try
    f:=TFileStream.Create(CurDir+'\'+NLgr+'.lgr',fmOpenRead);
    AssignFile(ft,NLgr+'\pictures.lst');
    if not FileExists('LGR') then CreateDir('LGR');
    CreateDir(NLgr);
    //ShowMessage(LabeledEdit1.Text+'\pictures.lst');
    f.Read(id[1],5);
    id[0]:=#5;
    if id<>'LGR12' then exit;
    f.Read(nofall,4);
    f.Read(dw,4);
    f.Read(nofp,4);
    SetLength(names,nofp);
    for i:=0 to nofp-1 do begin
     SetLength(names[i],9);
     f.Read(names[i,1],10);
     //Memo1.Lines.Add(names[i]);
    end;
    SetLength(Mas,nofp);
    for i:=0 to nofp-1 do begin
     SetLength(mas[i].tip,4);
     f.Read(mas[i].tip[1],4);
    end;
    for i:=0 to nofp-1 do
     f.Read(mas[i].dis,4);
    for i:=0 to nofp-1 do
     f.Read(mas[i].clip,4);
    for i:=0 to nofp-1 do
     f.Read(mas[i].unn,4);
    Rewrite(ft);
    for i:=0 to nofp-1 do with mas[i] do begin
      //Memo1.Lines.Add(mas[i].tip[1]);
      for j:=1 to 10 do
       if names[i,j]=#0 then names[i,j]:=' ';
      Write(ft,names[i]);
      case tip[1] of
        'd':Write(ft,'pict');
        'e':Write(ft,'text');
        'f':Write(ft,'mask');
      end;
      if tip[1]='f' then Writeln(ft) else begin
        Write(ft,' ',mas[i].dis,' ');
        case mas[i].clip of
          0:Writeln(ft,'u');
          1:Writeln(ft,'g');
          2:Writeln(ft,'s');
        end;
      end;
    end;
    CloseFile(ft);
    for i:=0 to nofall-1 do begin
      SetLength(name,12);
      f.Read(name[1],12);
      f.Read(dw,4);
      f.Read(dw,4);
      f.Read(dw,4);
      if not FileExists(NLgr+'\'+name) then begin
       f2:=TFileStream.Create(NLgr+'\'+name,fmCreate);
       f2.Free;
      end;
      f2:=TFileStream.Create(NLgr+'\'+name,fmOpenWrite);
      for j:=0 to dw-1 do begin
        f.Read(b,1);
        f2.Write(b,1);
      end;
      f2.Free;
    end;
  finally
    f.Free;
  end;
end;*)

procedure TLevel.WhatHere(p: TRPoint; var npol, n, tp: integer);
var
  i, j, x, y, nn, old: integer;
  Tmp: TALEImage;
  frt: integer;

function Near2(p2:TRPoint):boolean;
begin
  Result:=sqrt(sqr(p.x-p2.x)+sqr(p.y-p2.y))<RNear/Zoom;
end;

function NearLine(p1,p2: TRPoint):boolean;
var
  cosa: double;
  a,b,c,d: double;
begin
  Result:=false;
  a:= sqrt(sqr(p1.x-p2.x)+sqr(p1.y-p2.y));
  b:= sqrt(sqr(p.x-p2.x)+sqr(p.y-p2.y));
  c:= sqrt(sqr(p1.x-p.x)+sqr(p1.y-p.y));
  cosa:= (- c*c + a*a + b*b)/(2*a*b);
  if cosa <= 0 then Exit;
  d:= b;
  b:= c;
  c:= d;
  cosa:= (- c*c + a*a + b*b)/(2*a*b);
  if cosa <= 0 then Exit;
  if b*sqrt(1 - sqr(cosa)) < RNear/Zoom then Result:=true;
end;

begin
  tp:=tpNone;

  if UseNormalCapture then begin

    for i:=0 to High(Objects) do
     if Near2(Objects[i].Pos) then begin
       tp:=tpObject;
       n:=i;
       exit;
     end;

    for i:=0 to High(Pics) do
     if Near2(Pics[i].Pos) then begin
       tp:=tpPicture;
       n:=i;
       exit;
     end;

  end;

  if UseSmartCapture then begin

    for i:=0 to High(Objects) do begin

     x:=round((-Objects[i].Pos.x+p.x+Radius)*50);
     y:=round((-Objects[i].Pos.y+p.y+Radius)*50);

     if (Objects[i].typ=4) and not FrameObjects then begin
        x:=round(((-Objects[i].Pos.x+p.x)*50+58/pmoto/2)/124*512);
        y:=round(((-Objects[i].Pos.y+p.y)*50+273/pmoto/2)/114*512);
     end;

     case Objects[i].typ of
      1: Tmp:= QExit;
      2: begin
        if (Objects[i].AnimNumber>=1) and (Objects[i].AnimNumber<=9) then
         nn:=Objects[i].AnimNumber else nn:=1;
        if QFood[nn].Texture=nil then nn:=1;
        Tmp:= QFood[nn];
      end;
      3: Tmp:= QKiller;
      4: Tmp:= QMoto;
     end;

     if FrameObjects then frt:=ftObject
     else frt:=ftNone;

     if IsImageHere(Tmp,x,y,frt) then begin
       tp:=tpObject;
       n:=i;
       exit;
     end;
    end;

    i:=High(Pics);
    while i>=0 do begin
     old:=i;
     while (Pics[i].Distance=Pics[old].Distance) do begin
       dec(i);
       if (i<0) then break;
     end;

     for j:=i+1 to old do begin
       x:=round((-Pics[j].Pos.x+p.x)*50/1.041);
       y:=round((-Pics[j].Pos.y+p.y)*50/1.041);
                                                 
       frt:=ftNone;
       if Pics[j].Name<>'' then
         Tmp:=PC[SearchPic(Pics[j].Name)].Image
       else begin
         Tmp:=PC[SearchPic(Pics[j].Mask)].Image;
         if not FillTextures then frt:=ftPicture;
       end;

       if IsImageHere(Tmp,x,y,frt) then begin
         tp:=tpPicture;
         n:=j;
         exit;
       end;
     end;
    end;
  end;

  for i:=0 to High(Polygons) do with Polygons[i] do
   for j:=0 to High(Vertices) do
    if Near2(Vertices[j]) then begin
     tp:=tpVertex;
     npol:=i;
     n:=j;
     exit;
    end;

  for i:=0 to High(Polygons) do with Polygons[i] do
   for j:=0 to High(Vertices) do
    if NearLine(Vertices[j],Vertices[(j-1+Length(Polygons[i].Vertices)) mod Length(Polygons[i].Vertices)]) then begin
     tp:=tpPolygon;
     npol:=i;
     n:=j;
     exit;
    end;
end;

procedure TLevel.ZoomFill;
var
  maxx,maxy,minx,miny,w,h:double;
  i,j:integer;
begin
  if Polygons=nil then exit;
  if Objects=nil then exit;
  maxx:=Polygons[0].Vertices[0].x;
  minx:=Polygons[0].Vertices[0].x;
  maxy:=Polygons[0].Vertices[0].y;
  miny:=Polygons[0].Vertices[0].y;
  for i:=0 to Length(Polygons)-1 do with Polygons[i] do begin
    for j:=0 to Length(Vertices)-1 do with Vertices[j] do begin
      if x>maxx then maxx:=x;
      if x<minx then minx:=x;
      if y>maxy then maxy:=y;
      if y<miny then miny:=y;
    end;
  end;
  for i:=0 to Length(Objects)-1 do with Objects[i].Pos do begin
    if x+Radius>maxx then maxx:=x+Radius;
    if x-Radius<minx then minx:=x-Radius;
    if y+Radius>maxy then maxy:=y+Radius;
    if y-Radius<miny then miny:=y-Radius;
  end;
  for i:=0 to Length(Pics)-1 do with Pics[i],Pos do begin
    if Name<>'' then
     j:=SearchPic(Name)
    else j:=SearchPic(Mask);
    if j<0 then begin
      w:=0;
      h:=0;
    end else begin
      w:=PC[j].Width*pz;
      h:=PC[j].Height*pz;
    end;
    if x+w>maxx then maxx:=x+w;
    if x<minx then minx:=x;
    if y+h>maxy then maxy:=y+h;
    if y<miny then miny:=y;
  end;
  Center.x:=(maxx+minx)/2;
  Center.y:=(maxy+miny)/2;
  if maxx=minx then maxx:=minx+1e-10;
  if maxy=miny then maxy:=miny+1e-10;
  if (Width/(maxx-minx)<Height/(maxy-miny)) then Zoom:=Width/(maxx-minx)*0.95
  else Zoom:=Height/(maxy-miny)*0.95;
end;

{ TTool }

constructor TTool.Create(Par: TLevel);
begin
  Parent:=Par;
  x:=-1000;y:=-1000;
  State:=stReady;
  Pressed:=false;
  Parent.DXDraw.Cursor:=crDefault;
end;

procedure TTool.Setstate(const Value: integer);
var
  r:TRect;
begin
  FState:=Value;
  if FState=stReady then r:=Bounds(0,0,Screen.Width,Screen.Height)
  else begin
    r:=ALEForm.PaintBox1.ClientRect;
    r.TopLeft:=ALEForm.PaintBox1.ClientToScreen(r.TopLeft);
    r.BottomRight:=ALEForm.PaintBox1.ClientToScreen(r.BottomRight);
  end;
  ClipCursor(@r);
end;

procedure TTool.KeyPressed(key: word);
begin
  //
end;


end.